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;         }     } } 

2.4. vector的访问操作

为了符合我们C语言访问数组的习惯，我们可以先重载operator[]。当然我们也要提供两种不同的接口：可读可写与可读不可写。并且使用引用返回，减少不必要的拷贝。

// 可读可写 T& operator[](size_t pos) {     assert(pos < size());     return _start[pos]; } // 可读不可写 T& operator[](size_t pos)const {     assert(pos < size());     return _start[pos]; } 

同理我们也可以实现front()与back()函数。

// 可读可写 char& front() { 	return _start[0]; } char& back() { 	return _start[_size() - 1]; } // 可读不可写 const char& front()const { 	return _start[0]; } const char& back()const { 	return _start[_size() - 1]; } 

2.5. vector的修改操作

2.5.1. 常见的修改操作

首先我们将实现两个常用的修改函数：push_back()与pop_back()。

void push_back(const T& x) {     //判断是否扩容     if (_finish == _end_of_storage)     {         size_t newCapacity = capacity() == 0 ? 4 : 2 * capacity();         reserve(newCapacity);     }     *_finish = x;     ++_finish; } void pop_back() {     --_finish; } 

随后我们来实现数组的交换swap()函数，我们知道vector的交换其实就是指针_start，_finish，_end_of_storage的交换。

void swap(vector& v) {     std::swap(_start, v._start);     std::swap(_finish, v._finish);     std::swap(_end_of_storage, v._end_of_storage); } 

2.5.2. 迭代器失效

接下来我们实现insert()与erase()两个函数。其中insert()在插入时可能扩容，这时就需要记录起始长度，方便更新迭代器返回。

iterator insert(iterator pos, const T& x) {     assert(pos <= _finish && pos >= _start);     //检查是否扩容     if (_finish == _end_of_storage)     {         //先记录长度         size_t len = pos - _start;         size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;         reserve(newCapacity);         //更新迭代器指向新空间         pos = _start + len;     }     //往后覆盖     iterator end = _finish;     while (end > pos)     {         *end = *(end - 1);         --end;     }     *pos = x;     ++_finish;     return pos; } 

同样的为了防止迭代器失效，需要返回新的迭代器。

iterator erase(iterator pos) {     assert(pos >= _start && pos < _finish);     iterator end = pos + 1;     while (end != _finish)     {         *(end - 1) = *end;         ++end;     }     --_finish;     return pos; } 

3. 源码

#pragma once namespace betty { 	template 	class vector 	{ 	public: 		typedef T* iterator; 		typedef const T* const_iterator; 		vector() 			:_start(nullptr) 			,_finish(nullptr) 			,_end_of_storage(nullptr) 		{ 			; 		} 		vector(size_t n, const T& val = T()) 		{ 			resize(n, val); 		} 		vector(int n, const T& val = T()) 		{ 			resize(n, val); 		} 		template 		vector(InputIterator first, InputIterator last) 		{ 			while (first != last) 			{ 				push_back(*first); 				++first; 			} 		} 		//vector(const vector& v) 		//{ 		//	_start = new T[v.capacity()];//开辟capacity的空间 		//	for (size_t i = 0; i < v.size(); ++i) 		//	{ 		//		_start[i] = v._start[i];//循环拷贝 		//	} 		//	_finish = _start + v.size();//更新_finish 		//	_end_of_storage = _start + v.capacity();//更新_end_of_storage 		//} 		vector(vector& v) 		{ 			// 根据v的capacity()去开出对应的空间 			reserve(v.capacity()); 			//进行深拷贝 			for (size_t i = 0; i < v.size(); i++) 			{ 				push_back(v[i]); 			} 		} 		vector operator=(vector v) 		{ 			swap(v); 			return *this; 		} 		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 _end_of_storage - _start; 		} 		void reserve(size_t n) 		{ 			//提前原本记录长度 			size_t sz = size(); 			if (n > capacity()) 			{ 				T* tmp = new T[n]; 				if (_start) 				{ 					//深拷贝 					for (size_t i = 0; i < size(); i++) 					{ 						tmp[i] = _start[i];//赋值重载 					} 					delete[]_start; 				} 				_start = tmp; 				_finish = _start + sz; 				_end_of_storage = _start + n; 			} 		} 		void push_back(const T& x) 		{ 			//判断是否扩容 			if (_finish == _end_of_storage) 			{ 				size_t newCapacity = capacity() == 0 ? 4 : 2 * capacity(); 				reserve(newCapacity); 			} 			*_finish = x; 			++_finish; 		} 		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; 				} 			} 		} 		T& operator[](size_t pos) 		{ 			assert(pos < size()); 			return _start[pos]; 		} 		T& operator[](size_t pos)const 		{ 			assert(pos < size()); 			return _start[pos]; 		} 		iterator insert(iterator pos, const T& x) 		{ 			assert(pos <= _finish && pos >= _start); 			//检查是否扩容 			if (_finish == _end_of_storage) 			{ 				//先记录长度 				size_t len = pos - _start; 				size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2; 				reserve(newCapacity); 				//更新迭代器指向新空间 				pos = _start + len; 			} 			//往后覆盖 			iterator end = _finish; 			while (end > pos) 			{ 				*end = *(end - 1); 				--end; 			} 			*pos = x; 			++_finish; 			return pos; 		} 		iterator erase(iterator pos) 		{ 			assert(pos >= _start && pos < _finish); 			iterator end = pos + 1; 			while (end != _finish) 			{ 				*(end - 1) = *end; 				++end; 			} 			--_finish; 			return pos; 		} 		void pop_back() 		{ 			--_finish; 		} 		void swap(vector& v) 		{ 			std::swap(_start, v._start); 			std::swap(_finish, v._finish); 			std::swap(_end_of_storage, v._end_of_storage); 		} 		~vector() 		{ 			delete[]_start; 			_start = _finish = _end_of_storage = nullptr; 		} 	private: 		iterator _start; 		iterator _finish; 		iterator _end_of_storage; 	}; } ase(iterator pos) 		{ 			assert(pos >= _start && pos < _finish); 			iterator end = pos + 1; 			while (end != _finish) 			{ 				*(end - 1) = *end; 				++end; 			} 			--_finish; 			return pos; 		} 		void pop_back() 		{ 			--_finish; 		} 		void swap(vector& v) 		{ 			std::swap(_start, v._start); 			std::swap(_finish, v._finish); 			std::swap(_end_of_storage, v._end_of_storage); 		} 		~vector() 		{ 			delete[]_start; 			_start = _finish = _end_of_storage = nullptr; 		} 	private: 		iterator _start; 		iterator _finish; 		iterator _end_of_storage; 	}; }