【C++STL】vector的模拟实现

完整代码

#pragma once
#include "assert.h"
using namespace std;

namespace mySTL{

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

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

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

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

		//无参构造
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{}


		//vector<int> v1(10, 1);
		//vector<char> v1(10, 'A');
		vector(size_t n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n);
			for (size_t i = 0; i < n; ++i){
				push_back(val);
			}
		}

		//int a[4]={1,2,3,4}
		//vector<int> v1(a, a+4);
		template <class InputIterator>
		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			while (first != last){
				push_back(*first);
				++first;
			}
		}

		// 
		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			vector<T> tmp(v.begin(), v.end());
			swap(tmp);
		}

		// v1 = v2
		// v1 = v1;  // 极少数情况，能保证正确性，所以这里就这样写没什么问题
		vector<T>& operator=(vector<T> v){	// 重载 = 
			swap(v);
			return *this;
		}

		~vector(){
			delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}
		
		void reserve(size_t n){		// 扩容
			if (n > capacity()){
				size_t oldSize = size();
				T* tmp = new T[n];
				if (_start){
					//memcpy(tmp, _start, sizeof(T)*oldSize);
					for (size_t i = 0; i < oldSize; ++i){
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;
				_finish = tmp + oldSize;
				_endofstorage = _start + n;
			}
		}

		void resize(size_t n, T val = T()){ // 重置size。若新的size比容量要大，则需要扩容
			if (n > capacity()){
				reserve(n);
			}
			if (n > size()){
				while (_finish < _start + n){
					*_finish = val;
					++_finish;
				}
			}
			else{
				_finish = _start + n;
			}
		}

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

		size_t size() const{		// 实际存储数据的大小
			return _finish - _start;
		}

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

		void push_back(const T& x){ // 尾插
			if (_finish == _endofstorage){
				size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newCapacity);
			}

			*_finish = x;
			++_finish;
		}

		void pop_back(){			// 尾删
			assert(!empty());
			--_finish;
		}

		// 迭代器失效 : 扩容引起，野指针问题
		iterator insert(iterator pos, const T& val)
		{
			assert(pos >= _start);
			assert(pos < _finish);

			if (_finish == _endofstorage){
				size_t len = pos - _start;
				size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newCapacity);
				// 扩容会导致pos迭代器失效，需要更新处理一下
				pos = _start + len;
			}
			// 挪动数据
			iterator end = _finish - 1;
			while (end >= pos){
				*(end + 1) = *end;
				--end;
			}
			*pos = val;
			++_finish;
			return pos;
		}

		iterator erase(iterator pos){	// 删除
			assert(pos >= _start);
			assert(pos < _finish);
			iterator begin = pos + 1;
			while (begin < _finish){
				*(begin - 1) = *(begin);
				++begin;
			}
			--_finish;
			return pos;
		}

		// 找到了返回该值的迭代器，没找到返回空指针
		iterator find(const T& val) {
			iterator it = begin();
			while (it != end()) {
				if (*it == val) {
					return it;
				}
				++it;
			}
			return nullptr;
		}

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

		void clear(){
			_finish = _start;
		}

	private:
		iterator _start;
		iterator _finish;
		iterator _endofstorage;
	};
}

测试

将以上代码放入文件 命名为vector.h

#include "iostream"
#include "vector.h"

using namespace mySTL;


void print(vector<int>& arr) {
	if (arr.empty())
		cout << "null" << endl;
	for (int i = 0; i < arr.size(); i++) {
		cout << arr[i] << ' ';
	}	cout << endl;
}

void test1() {
	int a[] = { 1,2,3,4,5,6,0,7,8,9 };
	int len = sizeof(a) / sizeof(int);

	// 尾插
	vector<int> arr;
	for (int i = 0; i < len; i++) {
		arr.push_back(a[i]);
	}
	print(arr);


	// 查找
	int fnum = 5;
	vector<int>::iterator it = arr.find(fnum);
	if (it) {
		cout << *it << endl;
	}
	else {
		cout << "Not found" << endl;
	}

	// 任意位置插入删除
	arr.insert(it, 11);
	print(arr);

	arr.erase(it + 1);
	print(arr);

	// 尾删
	while (!arr.empty()) {
		arr.pop_back();
		print(arr);
	}
}

int main() {
	test1();
	return 0;
}