2024年最新【C++庖丁解牛】vector容器的简易模拟实现(C+(2)，2024年最新C C++开发基础视频

于 2024-05-14 13:35:05 发布
阅读量909 收藏 10
点赞数 21
分类专栏： 程序员 文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84976491/article/details/138851584
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

		// 2.空间不够则增容
		if (n > capacity())
			reserve(n);

		// 3.将size扩大到n
		iterator it = _finish;
		_finish = _start + n;
		while (it != _finish)
		{
			\*it = value;
			++it;
		}
	}


### 元素访问




	T& operator[](size_t pos)
	{
		assert(pos < size());
		return _start[pos];
	}

	const T& operator[](size_t pos)const
	{
		assert(pos < size());
		return _start[pos];
	}

	T& front()
	{
		return \*_start;
	}

	const T& front()const
	{
		return \*_start;
	}

	T& back()
	{
		return \*(_finish - 1);
	}

	const T& back()const
	{
		return \*(_finish - 1);
	}


### vector的修改操作




	void push\_back(const T& x)
	{
		insert(end(), x);
	}

	void pop\_back()
	{
		erase(end() - 1);
	}

	void swap(vector<T>& v)
	{
		std::swap(_start, v._start);
		std::swap(_finish, v._finish);
		std::swap(_endOfStorage, v._endOfStorage);
	}

	iterator insert(iterator pos, const T& x)
	{
		assert(pos <= _finish);

		// 空间不够先进行增容
		if (_finish == _endOfStorage)
		{
			//size\_t size = size();
			size_t newCapacity = (0 == capacity()) ? 1 : capacity() \* 2;
			reserve(newCapacity);

			// 如果发生了增容，需要重置pos
			pos = _start + size();
		}

		iterator end = _finish - 1;
		while (end >= pos)
		{
			\*(end + 1) = \*end;
			--end;
		}

		\*pos = x;
		++_finish;
		return pos;
	}

	// 返回删除数据的下一个数据
	// 方便解决:一边遍历一边删除的迭代器失效问题
	iterator erase(iterator pos)
	{
		// 挪动数据进行删除
		iterator begin = pos + 1;
		while (begin != _finish) 
		{
			\*(begin - 1) = \*begin;
			++begin;
		}

		--_finish;
		return pos;
	}


## 源代码

#pragma once

#include
using namespace std;
#include <assert.h>

namespace A
{
template
class vector
{
public:
// Vector的迭代器是一个原生指针
typedef T* iterator;
typedef const T* const_iterator;

	///
	// 构造和销毁
	vector()
		: \_start(nullptr)
		, \_finish(nullptr)
		, \_endOfStorage(nullptr)
	{}

	vector(size_t n, const T& value = T())
		: \_start(nullptr)
		, \_finish(nullptr)
		, \_endOfStorage(nullptr)
	{
		reserve(n);
		while (n--)
		{
			push\_back(value);
		}
	}

	/\*

* 理论上将，提供了vector(size_t n, const T& value = T())之后
* vector(int n, const T& value = T())就不需要提供了，但是对于：
* vector v(10, 5);
* 编译器在编译时，认为T已经被实例化为int，而10和5编译器会默认其为int类型
* 就不会走vector(size_t n, const T& value = T())这个构造方法，
* 最终选择的是：vector(InputIterator first, InputIterator last)
* 因为编译器觉得区间构造两个参数类型一致，因此编译器就会将InputIterator实例化为int
* 但是10和5根本不是一个区间，编译时就报错了
* 故需要增加该构造方法
*/
vector(int n, const T& value = T())
: _start(new T[n])
, _finish(_start + n)
, _endOfStorage(_finish)
{
for (int i = 0; i < n; ++i)
{
_start[i] = value;
}
}

	// 若使用iterator做迭代器，会导致初始化的迭代器区间[first,last)只能是vector的迭代器
	// 重新声明迭代器，迭代器区间[first,last)可以是任意容器的迭代器
	template<class InputIterator>
	vector(InputIterator first, InputIterator last)
	{
		while (first != last)
		{
			push\_back(\*first);
			++first;
		}
	}

	vector(const vector<T>& v)
		: \_start(nullptr)
		, \_finish(nullptr)
		, \_endOfStorage(nullptr)
	{
		reserve(v.capacity());
		iterator it = begin();
		const_iterator vit = v.cbegin();
		while (vit != v.cend())
		{
			\*it++ = \*vit++;
		}
		_finish = it;
	}

	vector<T>& operator=(vector<T> v)
	{
		swap(v);
		return \*this;
	}

	~vector()
	{
		if (_start)
		{
			delete[] _start;
			_start = _finish = _endOfStorage = nullptr;
		}
	}

	/
	// 迭代器相关
	iterator begin()
	{
		return _start;
	}

	iterator end()
	{
		return _finish;
	}

	const_iterator cbegin() const
	{
		return _start;
	}

	const_iterator cend() const
	{
		return _finish;
	}

	//
	// 容量相关
	size_t size() const
	{
		return _finish - _start;
	}

	size_t capacity() const
	{
		return _endOfStorage - _start;
	}

	bool empty() const
	{
		return _start == _finish;
	}

	void reserve(size_t n)
	{
		if (n > capacity())
		{
			size_t oldSize = size();
			// 1. 开辟新空间
			T\* tmp = new T[n];

			// 2. 拷贝元素
			// 这里直接使用memcpy会有问题吗？同学们思考下
			//if (\_start)
			// memcpy(tmp, \_start, sizeof(T)\*size);

			if (_start)
			{
				for (size_t i = 0; i < oldSize; ++i)
					tmp[i] = _start[i];

				// 3. 释放旧空间
				delete[] _start;
			}

			_start = tmp;
			_finish = _start + oldSize;
			_endOfStorage = _start + n;
		}
	}

	void resize(size_t n, const T& value = T())
	{
		// 1.如果n小于当前的size，则数据个数缩小到n
		if (n <= size())
		{
			_finish = _start + n;
			return;
		}

		// 2.空间不够则增容
		if (n > capacity())
			reserve(n);

		// 3.将size扩大到n
		iterator it = _finish;
		_finish = _start + n;
		while (it != _finish)
		{
			\*it = value;
			++it;
		}
	}

	///
	// 元素访问
	T& operator[](size_t pos)
	{
		assert(pos < size());
		return _start[pos];
	}

	const T& operator[](size_t pos)const
	{
		assert(pos < size());
		return _start[pos];
	}

	T& front()
	{
		return \*_start;
	}

	const T& front()const
	{
		return \*_start;
	}

	T& back()
	{
		return \*(_finish - 1);
	}

	const T& back()const
	{
		return \*(_finish - 1);
	}
	/
	// vector的修改操作
	void push\_back(const T& x)
	{
		insert(end(), x);
	}

	void pop\_back()
	{
		erase(end() - 1);
	}

	void swap(vector<T>& v)
	{
		std::swap(_start, v._start);
		std::swap(_finish, v._finish);
		std::swap(_endOfStorage, v._endOfStorage);
	}

	iterator insert(iterator pos, const T& x)
	{
		assert(pos <= _finish);

		// 空间不够先进行增容
		if (_finish == _endOfStorage)
		{
			//size\_t size = size();
			size_t newCapacity = (0 == capacity()) ? 1 : capacity() \* 2;
			reserve(newCapacity);

			// 如果发生了增容，需要重置pos
			pos = _start + size();
		}

		iterator end = _finish - 1;
		while (end >= pos)
		{
			\*(end + 1) = \*end;
			--end;
		}

		\*pos = x;
		++_finish;
		return pos;
	}

	// 返回删除数据的下一个数据
	// 方便解决:一边遍历一边删除的迭代器失效问题
	iterator erase(iterator pos)
	{
		// 挪动数据进行删除
		iterator begin = pos + 1;
		while (begin != _finish) {
			\*(begin - 1) = \*begin;
			++begin;
		}

		--_finish;
		return pos;
	}
private:
	iterator _start;		// 指向数据块的开始
	iterator _finish;		// 指向有效数据的尾
	iterator _endOfStorage;  // 指向存储容量的尾
};

}

/// /
/// 对模拟实现的vector进行严格测试
void TestBitVector1()
{
A::vector v1;
A::vector v2(10, 5);

int array[] = { 1,2,3,4,5 };
A::vector<int> v3(array, array + sizeof(array) / sizeof(array[0]));

A::vector<int> v4(v3);

for (size_t i = 0; i < v2.size(); ++i)
{
	cout << v2[i] << " ";
}
cout << endl;

auto it = v3.begin();
while (it != v3.end())
{
	cout << \*it << " ";
	++it;
}
cout << endl;

for (auto e : v4)
{
	cout << e << " ";
}
cout << endl;

}

void TestBitVector2()
{
A::vector v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
cout << v.size() << endl;
cout << v.capacity() << endl;
cout << v.front() << endl;
cout << v.back() << endl;
cout << v[0] << endl;
for (auto e : v)
{
cout << e << " ";
}
cout << endl;

v.pop\_back();
v.pop\_back();
for (auto e : v)
{
	cout << e << " ";
}
cout << endl;

v.insert(v.begin(), 0);
for (auto e : v)
{
	cout << e << " ";
}
cout << endl;

v.erase(v.begin() + 1);
for (auto e : v)
{

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

cout << e << " ";
}
cout << endl;

v.insert(v.begin(), 0);
for (auto e : v)
{
	cout << e << " ";
}
cout << endl;

v.erase(v.begin() + 1);
for (auto e : v)
{

[外链图片转存中…(img-2gcCtqH4-1715664882675)]
[外链图片转存中…(img-Dkh2bPVh-1715664882675)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84976491
关注
  • 21
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值