深入理解并解析C++ stl::vector

拷贝构造
vector(const vector<T>& v)
{
  _start = new T[v.capacity()];

  memcpy(_start, v._start, sizeof(T) * v.size());
	
  _finish = _start + v.size();
  _endofstorage = _start + v.capacity();

}

//扩容
void reserve(size_t n)
{
 if (n > capacity())
 {
	size_t sz = size();
	T* tmp = new T[n];
	if (_start)
	{
	  memcpy(tmp, _start, sizeof(int) * size());
			
	  delete[] _start;

	}
	  _start = tmp;
	  _finish = _start + sz;
	  _endofstorage = _start + n;
	}
}

上述拷贝构造函数，当vector存的是内置类型是正常的。一旦vector存的是自定义类型时，例如vector<string>会出问题，由于memcpy导致的。

1. memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中。

2. 如果拷贝的是内置类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。

浅拷贝:

解决方式:

//拷贝函数
vector(const vector<T>& v)
{
	_start = new T[v.capacity()];

	//memcpy(_start, v._start, sizeof(T) * v.size());
	for (size_t i = 0; i <v.size(); i++)
	{
		_start[i] = v._start[i];//例如是string，调用string的赋值(=)重载(进行深拷贝)

	}
	_finish = _start + v.size();
	_endofstorage = _start + v.capacity();

}


//扩容
void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t sz = size();
		T* tmp = new T[n];
		if (_start)
		{
			//memcpy(tmp, _start, sizeof(int) * size());
			for (size_t i = 0; i < sz; i++)
			{
				 tmp[i]=_start[i];//例如是string，调用string的赋值(=)重载(进行深拷贝)

			}
			delete[] _start;

		}
		_start = tmp;
		_finish = _start + sz;
		_endofstorage = _start + n;
	}
}

结论：如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是浅拷贝，否则可能会引起内存泄漏甚至程序崩溃。

5.动态二维数组存储形式

6.vector的模拟实现

6.1反向迭代器的实现

可多容器复用。

成员变量是正向迭代，和正向迭代的逻辑是反的。

template<class iterator,class Ref,class Ptr>
struct Reverse_iterator
{
public:
	typedef Reverse_iterator<iterator,  Ref,  Ptr> Self;
	iterator _it;

	Reverse_iterator(iterator it)
		:_it(it)
	{ }

	Self operator++()
	{
		--_it;
		return *this;
	}

	Self operator--()
	{
		++_it;
		return  *this;
	}

	Ref operator*()
	{
		iterator tmp = _it;

		return  *(--tmp);
	}

	Ptr operator->()
	{
		return &(operator*());
	}
	bool operator!=(const Self& s) const
	{
		return _it != s._it;
	}
};

6.2常用函数的模拟实现

template<class T>
class vector
{
public:
	//正向迭代器
	typedef T* iterator;
	typedef const T* const_iterator;

	//方向迭代器
	typedef Reverse_iterator<iterator, T&, T*>  reverse_iterator;
	typedef Reverse_iterator<const_iterator, const T&, const T*> reverse_const_iterator;

	//反向迭代器
	reverse_iterator rbegin()
	{
		return _finish;
	}
	reverse_iterator rend()
	{
		return _start;
	}
	reverse_const_iterator rbegin() const
	{
		return _finish;
	}
	reverse_const_iterator rend() const
	{
		return _start;
	}

	iterator begin()
	{
		return _start;
	}
	iterator end()
	{
		return _finish;
	}

	const_iterator begin()const
	{
		return _start;
	}
	const_iterator end()const
	{
		return _finish;
	}

	
	vector()
	{}

		vector(const vector<T>& v)
	{
		_start = new T[v.capacity()];

		//memcpy(_start, v._start, sizeof(T) * v.size());
		for (size_t i = 0; i <v.size(); i++)
		{
			_start[i] = v._start[i];//例如是string，调用string的赋值(=)重载(进行深拷贝)

		}
		_finish = _start + v.size();
		_endofstorage = _start + v.capacity();

	}

	//复用已实现的接口
	/*vector(const vector<int>& v)
	{
		_start = reserve(v.capacity());
	
		for (auto& e : v)
		{
			push_back(e);
		}

	}*/
	//vector<int> v1(10u, 1);
	//vector<string> v2(10, "1111");

	//vector<int> v3(10, 1);
	vector(int n, const T& val = T())
	{
		resize(n, val);

	}

	vector(size_t n, const T& val=T())
	{
		resize(n, val);
	}

	//迭代器区间初始化
	template<class InputIterator>
	//[first,last)
	vector(InputIterator first, InputIterator last)
	{
		reserve(last - first);

		while (first != last)
		{
			*_finish = *first;
			++first;
			++_finish;
		}

	}
	//析构函数
	~vector()
	{
		if (_start != nullptr)
		{
			delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}
	
	}
	void swap(vector<T>& v)
	{
		std::swap(_start, v._start);
		std::swap(_finish, v._finish);
		std::swap(_endofstorage, v._endofstorage);

	}
	vector<T>& operator=(vector<T> v)
	{
		swap(v);
		return *this;
	}
	//扩容
	void reserve(size_t n)
	{
		if (n > capacity())
		{
			size_t sz = size();
			T* tmp = new T[n];
			if (_start)
			{
				//memcpy(tmp, _start, sizeof(int) * size());
				for (size_t i = 0; i < sz; i++)
				{
					 tmp[i]=_start[i];//例如是string，调用string的赋值(=)重载(进行深拷贝)

				}
				delete[] _start;

			}
			_start = tmp;
			_finish = _start + sz;
			_endofstorage = _start + n;
		}
	}
	//尾插
	void push_back(const T& val)
	{
		/*if (_finish == _endofstorage)
		{
			size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
			reserve(newcapacity);

		}
		*_finish = val;
		++_finish;*/
		insert(end(), val);
	}
	//尾删
	void pop_back()
	{
		auto pos = end();
		erase(--pos);
		//erase(--end());

	}

	void resize(size_t n, const T& val = T())
	{
		if (n < size())
		{
			_finish = _start + n;
		}
		else
		{
			reserve(n);
			while (_finish != _start + n)

			{
				*_finish = val;
				++_finish;
			}

		}
	}
	//pos位置前插入
	iterator insert(iterator pos, const T& val)
	{
		assert(pos >= _start && pos <= _finish);
		if (_finish == _endofstorage)
		{
			size_t gap = pos - _start;
			size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
			reserve(newcapacity);
			pos = _start + gap;		//防止扩容的时候失效
		}
		iterator end = _finish - 1;
		while (end >= pos)
		{
			*(end + 1) = *end;
			--end;
		}
		*pos = val;
		_finish++;
		return pos;
	}
	//删除pos位置的数据
	iterator erase(iterator pos)
	{
		assert(pos >= _start && pos <= _finish);
		iterator end = pos + 1;
		while (end != _finish)
		{
			*(end - 1) = *end;
			++end;
		}

		_finish--;

		return pos;
	}

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

	size_t size() const
	{
		return _finish - _start;
	}

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

private:

	T* _start=nullptr;
	T* _finish=nullptr;
	T* _endofstorage=nullptr;
};

觉得不错的记得点赞+收藏咯!!!