模拟实现vector:vector构造、析构函数、size、capacity、push_back函数、迭代器、[]运算符重载函数、insert、rease、pop_back、resize等函数的介绍

---

前言

模拟实现vector:vector构造、析构函数、size、capacity、push_back函数、迭代器、[]运算符重载函数、insert、rease、pop_back、resize等函数的介绍

---

一、vecotr构造、析构函数、size、capacity、push_back函数、迭代器、[]运算符重载

参考vector的源代码，vector的成员变量的结构:

private：
	iterator _start;
	iterator _finish;
	iterator _end_of_storage;

iterator为模板指针类型，通过typedef重命名。

• vector的结构大致为如下:

#include <iostream>
#include <assert.h>

using namespace std;


namespace hhb
{
	template <class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		iterator begin() 
		{
			return _start;
		}

		iterator end() 
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}


		vector()
			: _start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{

		}

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


		void push_back(const T& x)
		{
			size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
			if (_finish == _end_of_storage)
			{
				reserve(newcapacity);
			}

			*_finish = x;
			++_finish;

		}


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

		//		delete[] _start;

		//		_finish = tmp + size();

		//		_start = tmp;

		//		_end_of_storage = _start + n;
		//	}
		//	
		//}


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

				delete[] _start;
				_start = tmp;
				_finish = _start + sz;
				_end_of_storage = _start + n;
			}

		}


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




	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;
	};
}

• resereve的经典小坑：

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

		_start = tmp;
		_finish = _start + size();
		_end_of_storage = _start + n;

	}
}

如上述的写法：

测试执行

#include "vector.h"

void Test_vector1()
{
	hhb::vector<int> v1;

	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);


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


	hhb::vector<int>::iterator it = v1.begin();

	while (it != v1.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;


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


int main()
{
	
	Test_vector1();

	//Test_vector2();

	//Test_vector3();

	return 0;
}

二、insert函数

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

	if (_finish == _end_of_storage)
	{
		size_t len = pos - _start;

		size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
		reserve(newcapacity);

		pos = _start + len;

	}

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

	*pos = x;
	++_finish;

	return _start;
}

• 这里会有一个迭代器失效的坑
  

三、const修饰的迭代器

void print(const hhb::vector<int>& v)
{
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
}
void Test_vector3()
{
	hhb::vector<int> v1;

	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	v1.push_back(6);
	v1.push_back(7);
	v1.push_back(8);


	print(v1);
}

• 如上述的情况，print函数的参数经过了const修饰
• 在函数内部使用范围for语法糖，所以必须要有const修饰的迭代器。

四、erase函数

• 这里之所以不适用memcpy是因为，若遇到vector的成员变量是动态申请的空间时，会进行浅拷贝导致报错。比如： vector<string>

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

	return pos;
}

---

void Test_vector4()
{
	hhb::vector<int> v1;

	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	v1.push_back(6);
	v1.push_back(7);
	v1.push_back(8);
	v1.push_back(9);
	v1.push_back(0);

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

	v1.erase(v1.begin() + 3);
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

}

五、pop_back函数

• 直接调用erase函数删除最后一个元素

void pop_back()
{
	erase(end() - 1);
}

---

void Test_vector5()
{
	hhb::vector<int> v1;

	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	v1.push_back(6);
	v1.push_back(7);
	v1.push_back(8);
	v1.push_back(9);
	v1.push_back(0);


	v1.pop_back();
	v1.pop_back();
	v1.pop_back();
	v1.pop_back();


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

六、resize函数

• 三种情况
• n 比 size（）小
• n 比 size（）大 但是 比 capacity（）
• n 比 size（）小 但是 比 capacity（）

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

---

void Test_vector6()
{
	hhb::vector<int> v;
	v.resize(10, 0);


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

七、拷贝构造函数

• 拷贝构造函数需要进行 初始化
• 初始化列表可以不写，因为C++11的补丁，在成员变量声明时直接给缺省值

private:
	iterator _start = nullptr;
	iterator _finish = nullptr;
	iterator _end_of_storage = nullptr;

---

vector(const vector<T>& v)
{
	T* tmp = new T[v.capacity()];
	if (v._start)
	{
		//memcpy(tmp, v._start, sizeof(T) * v.size());
		for (size_t i = 0; i < v.size(); i++)
		{
			tmp[i] = v._start[i];
		}
		delete[] _start;
	}

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


// 现代写法
//vector(const vector<T>& v)
//	: _start(nullptr)
//	, _finish(nullptr)
//	, _end_of_storage(nullptr)
//{
//	reserve(v.capacity());
//	for (auto e : v)
//	{
//		push_back(e);
//	}
//}

---

void Test_vector7()
{
	hhb::vector<int> v1;

	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);


	hhb::vector<int> v2(v1);
	for (auto e : v2)
	{
		cout << e << " ";
	}
	cout << endl;
	

	hhb::vector<string> v3;

	v3.push_back("1111111");
	v3.push_back("2222222");
	v3.push_back("3333333");
	v3.push_back("4444444");
	v3.push_back("5555555");

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

	hhb::vector<string> v4(v3);

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

八、=赋值运算符重载函数

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

// 赋值运算符 // 现代写法
vector<T>& operator=(vector<T> v) 
{
	swap(v);
	return *this;
}

---

void Test_vector8()
{
	hhb::vector<int> v1;

	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);


	hhb::vector<int> v2;
	v2 = v1;
	for (auto e : v2)
	{
		cout << e << " ";
	}
	cout << endl;
}

九、构造函数重载

• 构造函数的初始化列表直接不写，采用C++11的补丁，直接在成员变量声明时给缺省值。
• T() 对于自定义类型，调用自定义类型的默认构造函数
• 对于内置类型，C++对内置类型进行了升级，内置类型也有默认构造函数。

vector()
{}

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

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



template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
	while (first != last)
	{
		push_back(*first);
		++first;
	}
}

---

void Test_vector10()
{
	//hhb::vector<int> v(10u, 1);
	hhb::vector<int> v(10, 1);




	hhb::vector<int> v1(v.begin(), v.end());
	
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;


	string s("hello world");
	hhb::vector<char> v2(s.begin(), s.end());

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


	int a[] = { 16,23,68,92,35 };
	hhb::vector<int> v3(a, a + sizeof(a) / sizeof(a[0]));

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

}

---

总结

模拟实现vector:vector构造、析构函数、size、capacity、push_back函数、迭代器、[]运算符重载函数、insert、rease、pop_back、resize等函数的介绍