c++顺序表初始（vector）

前言

std是一个容器和算法相关的库，顺序表作为一个常见的容器也在标准库中有相应的实现--vector。今天我们就来简单的认识一下vector的使用，并且简单的模拟实现一个我们的vector

具体vector类的描述可以参考vector - C++ Reference (cplusplus.com)

在不同的编译器下string类的实现各有差异，这里我们使用的是Microsoft Visual Studio Community 2022 (64 位) - Current 版本 17.8.5

构造函数

介绍

了解一个类，首先我们要先了解它的构造函数

声明一下，allocator_type是std六大组件之一的空间配置器，目前我们可以直接将其忽略。

首先vector提供了一个默认的构造函数--default(1)，我们简单的写一段程序来观察一下

此时我们首先可以得到一个结论，那就是默认的构造函数会将属性赋值为0（这里泛指各种0，例如数字0，0.0亦或是指针nullptr）。其次我们发现标准库使用的是三个指针来维护这个顺序表的。

我们合理猜测_Myfirst标识这块空间的开始位置，_Mylast标识这块空间最后一个有效元素的下一个位置，_Myend标识这块空间结束的下一个位置。

这样_Mylast-_Myfirst就能得到size（有效元素个数）,_Myend_Myfirst就能得到capacity（有效元素个数）

第二个构造函数可以一次性初始化n个元素，这个元素可以指定，不指定则使用默认值（这里会调用元素类型的默认构造）

第三个构造函数可以使用迭代器区间（左开右闭）来初始化，这可以和其他容器适配（因为容器是std六大组件之一，std的使用容器都支持迭代器）

第四个就是一个拷贝构造，这里还是要注意深浅拷贝的问题

实现

首先vector应该可以存储各种各样的数据类型，我们也实现一个类模板来适配各种数据类型，我们也学习标准库里用三个指针维护顺序表的方式实现

namespace zzzyh {
	template<class T>
	class vector
	{
	public:
        typedef T* iterator;
    private:
	    iterator _start = nullptr;//开始位置
	    iterator _finish = nullptr;//有效元素的下一个位置
	    iterator _end_of_storage = nullptr;//结束位置的下一个位置
    };
}

这里T类型就是要存储的数据类型，我们也发现顺序表这种结构下的指针就是天然的迭代器，我们定义T*为迭代器（当然标准库的实现要比我们这复杂很多，包括但不限于各种检查，我们这里就实现它基础的功能）

有了类的框架，我们就可以来实现他的构造函数

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

默认构造很简单，直接全部赋为空值即可

vector(int size,const T& x = T())
{
	T* tmp = new T[size];
	_start = _finish = tmp;
	_end_of_storage = tmp + size;
	for (size_t i = 0; i < size; i++)
	{
		push_back(x);
	}
}

这里我们可以初始化n个元素，并且指定初始化的值。这里我们复用了push_back方法，它的作用是尾插一个指定元素，但它的实现还是略微有点复杂，还牵扯到扩容（reserve）的逻辑，这两块内容我们在后面展开，这里先都直接使用了

我们再来实现一个拷贝构造

vector(const vector& tmp)
{
	size_t size = tmp.size();
	reserve(size);
	for (auto& x : tmp) {
		push_back(x);
	}
}

这里还是要注意深浅拷贝的问题，不能简答的理解为赋值操作，而是要开辟一块独立的空间出来

最后我们要来实现一个迭代器区间的构造函数

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

在类模板中我们依然可以使用函数模板，此时使用函数模板就可以实现接收各种各样的迭代器

注意，while条件里最好还是使用!=号，因为某些容器在内存上是不连续的（例如链表）

析构函数

介绍

显然，这个类是有资源需要释放的，那么使用我们默认生成的析构函数是有内存泄露的风险的，需要我们再自己实现一份

实现

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

这里如果_start是nullptr不会做任何处理，我们就不检查了

operator=

operator=也是默认生成的函数，但我们在拷贝构造的部分就讲了，vector是存在深浅拷贝的问题就的，所以我们同样还需要手动实现operator=

//template<class T> 类的内部不需要
vector<T>& operator=(const vector<T>& tmp) {
	if (this == &tmp) {
		return *this;
	}
	vector<T> v(tmp);
	swap(v);
	return *this;
}

迭代器

这里的迭代器用法和功能上和我们再string里讲的完全相同，我们就挑前四个简单实现一下

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

typedef const T* const_iterator;

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

下面两组关于逆遍历的迭代器我们就先不展开了

容量相关操作

对于一个容器，容量相关的操作尤为重要，下面我们边介绍边实现一些常用的容量操作函数

size

得到数据的个数

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

capacity

得到最大容量

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

empty

判断容器是否为空，即有没有有效元素，空返回true，否则返回false

bool empty() {
	return _finish == _start;
}

reserve

reserve可以将容量增加到不小于指定大小。如果指定大小小于等于当前容量不做任何处理，大于当前容量会将容量增加到不小于指定大小，具体多大取决于编译器的实现，只保证不会影响数据

void reserve(size_t n) {
			size_t sz = size();
			size_t oldCapacity = capacity();
			if (n <= oldCapacity) {
				return;
			}
			int newCapacity = n > oldCapacity*2 ? n : oldCapacity * 2;
			T* rem = new T[newCapacity];
			if (sz != 0) {
				//memmove(rem, _start, sizeof(T) * sz);
				for (size_t i = 0; i < sz; i++)
				{
					rem[i] = _start[i];
				}
				//delete[] _start;
			}
			delete[] _start;
			_start = rem;
			_finish = rem + sz;
			_end_of_storage = rem + newCapacity;
}

reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代
价缺陷问题

resize

resize则会影响数据。如果指定大小<原大小，会将数据减少至指定大小；如果指定大小==原大小数据层面可以理解为不做处理，如果指定大小>原大小则会扩容至指定大小，可以指定扩容使用的值，不指定依然使用默认值。resize在开空间的同时还会进行初始化，影响size

void resize(size_t n,const T& x = T()) {
			if (n == size()) {
			}
			else if (n < size()) {
				_finish = _start + n;
			}
			else {
				reserve(n);
				int i = n-size() ;
				while (i > 0)
				{
					this->push_back(x);
					i--;
				}
			}
			return;
}

增删改查操作

push_back

这可以尾插一个指定的元素，前面我们多次使用它，现在我们就来简单的实现一下

void push_back(const T& data) {
			if (_finish == _end_of_storage) {
				reserve(capacity() == 0 ? 1 : capacity() * 2);
			}
			new(_finish)T(data);//这里和下面注释的代码起到相同的效果，不过这里是拷贝构造
			//*_finish = data; 这里是赋值重载
			_finish++;
}

pop_back

尾删一个元素，并且弹出元素的值（标准库中未弹出，没有返回值，我们这里实现一个弹出版本的）

T pop_back() {
	if (!empty()) {
		T ret = *(_finish - 1);
		_finish--;
		return ret;
	}
}

find

查询第一个符合指定的元素，如果查询到返回此元素的迭代器，否则返回有效元素的下一个位置

注意，这是std算法模块提供的函数，所以我们在vector中不提供具体实现，只简单介绍其用法

insert

在pos位置之前插入一个指定的元素

iterator insert(iterator pos, const T& data) {
	assert(pos >= _start && pos <= _finish);
	if (pos == _finish) {
		push_back(data);
		return pos+1;
	}
	if (_finish == _end_of_storage) {
		int i = pos - _start;
		reserve(capacity() == 0 ? 1 : capacity() * 2);
		pos = _start + i;
	}
	iterator end = this->end()-1;
	while (end >= pos) {
		//memmove(end + 1, end, sizeof(T));
		*(end + 1) = *(end);
		end--;
	}
	new(pos)T(data);
	_finish++;
	return pos+1;
}

clear

清除所有元素

void clear() {
			_finish = _start;
		}

operator[]

得到指定下标的元素

		T& operator[](int i) {
			return *(_start + i);
		}

		const T& operator[](int i) const 
		{
			return *(_start + i);
		}

swap

交换两个容器的内容

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

erase

删除指定位置的元素

iterator erase(iterator pos)
		{
			assert(pos >= _start && pos < _finish);
			if (pos == _finish - 1) {
				pop_back();
				return pos-1;
			}
			//delete (this[pos - _start]);
			//int i = pos - _start;
			//memmove(pos, pos + 1, sizeof(T) * (size() - 1 - (pos - _start)));
			iterator left = pos;
			while (left!=_finish-1) {
				*left = *(left + 1);
				left++;
			}
			//pos = _start+i;
			_finish--;
			return pos;
		}