C++ vector之模拟实现

第二章 STL

成员变量

---

namespace hek
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef  const T* const_iterator;

       ......  各种函数

	private:
		iterator _start;		// 指向第一个位置
		iterator _finish;		// 指向最后一个的下一个位置
		// _finish - _strat = size。
		iterator _endofstorage; // 指向开辟空间的最后一个的下一个位置
		// _endofstorage - _strat = cappacity。
	};

默认成员函数

---

        // 构造函数
        vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
		}
        
        // 拷贝构造函数
		//vector(const vector<T>& v)
		//{
		//	_start = new T[v.capacity()];
		//	_finish = _start;
		//	_endofstorage = _start + v.capacity();
		//	// 1
		//	for (auto& vv : v)
		//	{
		//		*_finish = vv;
		//		_finish++;
		//	}
		//	// 2
		//	/*for (size_t i = 0; i < v.size(); i++)
		//	{
		//		*_finish = v[i];
		//		_finish++;
		//	}*/
		//}
        // 拷贝构造的优化 , 复用了reserve函数
		vector(const vector<T>& v)
			:_start(nullptr)
			,_finish(nullptr)
			,_endofstorage(nullptr)
		{
			reserve(v.capacity());
			for (const auto& i : v)
			{
				push_back(i);
			}
		}
        

		// v1 = v2;
		/*vector<T>& operator=(const vector<T>& v)
		{
			if (this != &v)
			{
				delete[] _start;
				_start = new T[v.capacity()];

				memcpy(_start, v._start, sizeof(T) * v.size());
				_finish = _start +v.size();
				_endofstorage = _start + v.capacity();
			}
			return *this;
		}*/
		// 
		vector<T>& operator=(vector<T> v)
		{
			swap(v);  // 隐含的this指针 ，相当于 this->swap(v);
			return  *this;
		}
		void swap(vector<T>& v)
		{
			::swap(_start, v._start);
			::swap(_finish, v._finish);
			::swap(_endofstorage, v._endofstorage);
		}
        
        // 析构函数
		~vector()
		{
			delete[] _start;
			_start = nullptr;
			_finish = nullptr;
			_endofstorage = nullptr;
		}

迭代器

---

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

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

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

增删改查

---

		// 增容
        void reserve(size_t newcapacity)
		{
			if(newcapacity > capacity() )
			{
				size_t sz = size();
				T* tmp = new T[newcapacity];
				if (_start)  // 当_start不为空
				{
					//  按字节拷贝，浅拷贝
					//memcpy(tmp, _start, sizeof(T) * size());
					for (size_t i = 0; i < sz; i++)
					{
                        // 如果T是string,
						// 调用的就是T的  operator=  深拷贝
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;
				_finish = tmp + sz;
				_endofstorage = tmp + newcapacity;
			}
		}
		void resize(size_t n,const T& x = T() )  // T() -> int()
		{
			if (n > size())
			{
				if (n > capacity())
				{
					reserve(n);
				}
				while (_finish < (n + _start))
				{
					*_finish = x;
					_finish++;
				}
			}
			else{
				_finish = _start + n;
			}
		}
    
        // 添加元素
		void push_back(const T& x)
		{
			/*if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = x;
			_finish++;*/

			insert(_finish, x); // 复用

		}

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

				size_t n = pos - _start; // 因为增容后，原pos指向的空间被释放
				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(newcapacity);
				// 重新计算位置。
				pos = _start + n;
			}
			iterator end = _finish-1;
			
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x;
			_finish++;
		}
        
        // 删除元素
		void pop_back()
		{
			/*assert( size() >= 0);
			--_finish;*/
			erase(_finish-1);  // 复用

		}
		iterator erase(iterator pos)
		{
			assert(pos < _finish);
			iterator it = pos;
			while (it < _finish)
			{
				*it = *(it + 1);
				it++;
			}
			_finish--;
			return pos;
		}

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