Vector容器-优快云博客

本文深入探讨了C++ STL中array与vector容器的区别，array为固定大小，而vector则能动态调整大小。同时，文章提供了一段自定义实现的vector模板类代码，展示了如何手动实现类似STL vector的功能，包括迭代器、元素访问、容器操作等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

vector为序列式容器，并不会对元素进行排序，元素的顺序和存储它们的顺序一样。
要说这个vector动态数组，咱们就必须先来了解一下array这个静态数组。
1.和标准容器相比，array的空间开销格外的小。(这提供了两个优点，如果使用at(),当用一个非法的索引访问数组元素时可以被检测到。数组容器可以作为参数传给函数，而不再需要单独去指定数组元素的个数)
2.使用容器array需要在源文件中包含头文件array。
3.如果定义了一个 array 容器，却没有为元素指定初始值，那么元素就不会被初始化
4.当创建 array 容器的实例时，要像创建常规数组那样，对元素进行初始化。

 array<int,5> a1;//array<T,n>定义的是有n个T类型的元素
	a1.assign(3);//将空间全部添加上元素的值。
	a1.at(2);//在下标为2处元素的值
	a1.fill(1);//将所有的位置填上值和assign是底层代码一样的
	for (array<int, 5>::iterator it = a1.begin(); it != a1.end(); it++)
	{
		cout << *it << "\t";
	}
	cout << endl;
	cout << a1.front() << endl;//输出元素的头部元素的值
	cout << a1.back() << endl;//输出元素尾部元素的值
	array<int, 5> a2;
	int i = 0;
	for (array<int, 5>::iterator it = a2.begin(); it != a2.end(); it++)//使用迭代器对元素进行遍历
	{
		i++;
		*it = i;
	}
	cout << *a2.data() << endl;//首元素的地址

下面接着说vector吧
vector 容器是包含 T 类型元素的序列容器，和 array<T，N> 容器相似
不同的是 vector 容器的大小可以自动增长，从而可以包含任意数量的元素。
1.当vector容器中的元素数量超过vector当前容量时其就会自动分配内存。
2.vector可以方便灵活的替换数组，在大多数情况下并不会拖慢代码的效率。

vector<int> v1;
	v1.assign(1,2);//assign(n,T)追加n个T类型的元素
	v1.at(0);//at(n)取出下标为n的元素。
	cout << v1.capacity() << endl;//容器的容量
	cout << v1.max_size() << endl;//容器所能容纳的最大容量
	cout<<v1.size() << endl;//容器中元素值得数量
	
	for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++)
	{
		cout << *it << "\t";
	}
	cout << endl;
	cout << v1.data() << endl;;//传回首元素的地址
	v1.clear();//把容器v1清空。

下面是一段自定义实现vector模板类的的部分功能的模板类：

#include<iostream>
#include<stdexcept>
using std::cout;
using std::endl;
template<class T>
class CVector
{
private:
	T *pBuff;
	size_t len;//size_t用来作为数组下标，其为无符号>0
	size_t maxSize;//数组最大容量
public:
	CVector();//构造函数
	CVector(size_t n, const T&elem);
    CVector(const CVector<T> &v1);
	~CVector();//析构函数
public://自制迭代器
	struct MyIterator
	{
		T*pIt;
		MyIterator&operator=(const MyIterator&src)
		{
			pIt = src.pIt;
			return *this;
		}
		bool operator==(const MyIterator&src)
		{
			if (pIt == src.pIt)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		bool operator!=(const MyIterator&src)
		{
			return !((*this) == src);
		}
		MyIterator&operator++()
		{
			pIt++;
			return *this;
		}
		MyIterator operator++(int)
		{
			MyIterator temp = *this;
			pIt++;
			return temp;
		}
		T&operator*()
		{
			return *pIt;
		}
	};
	MyIterator begin()
	{
		MyIterator temp;
		temp.pIt = pBuff;
		return temp;
	}
	MyIterator end()
	{
		MyIterator temp;
		temp.pIt = pBuff + len;
		return temp;
	}
public:
	T &at(int index)const;//返回下标为index的元素的值
	void clear();//清空容器
	void assign(size_t n,const T&elem);//赋值n个elem值
	T& back()const;//尾元素
	T& front()const; //首元素
	void push_back(const T &elem);//尾部插入
public:
	void swap(CVector<T>&v1);//交换容器内元素的值
	friend void swap1(CVector<T>&v1, CVector<T> &v2)
	{
		v1.swap(v2);
	}
public:
	bool operator==(const CVector<T>&v1);//重载==运算符
	bool operator!=(const CVector<T>&v1);//重载！=运算符
	bool operator>(const CVector<T>&v1);//重载>运算符
	bool operator>=(const CVector<T>&v1);//重载>=运算符
	bool operator<(const CVector<T>&v1);//重载<运算符
	bool operator<=(const CVector<T>&v1);//重载<=运算符
	T operator[](size_t index);//重载下标运算符
	CVector<T>& operator=(const CVector<T>&v1);//重载赋值运算符
public:
	void print()const;//打印函数
	size_t size()const;//输出容器内元素的大小
	size_t max_size()const;//输出容器的最大容量
};
template<class T>
CVector<T>::CVector()
{
	len = maxSize = 0;
	pBuff = nullptr;
}
template<class T>
CVector<T>::CVector(size_t n, const T&elem)
{
	if (n > 0)
	{
		pBuff = new T[n];
		len = maxSize = n;
		for (size_t i = 0; i < len; i++)
		{
			pBuff[i] = elem;
		}
	}
}
template<class T>
CVector<T>::CVector(CVector<T> const&v1)
{
	if (v1.len>0)
	{
		len = v1.len;
		maxSize = v1.maxSize;
		pBuff = new T[maxSize];
		for (size_t i = 0; i < len; i++)
		{
			pBuff[i] = v1.pBuff[i];
		}
	}
}
template<class T>
T& CVector<T>::at(int index)const
{
	if (index < 0||len<=index)
	{
		throw out_of_range("越界");
	}
	return pBuff[index];
}

template<class T>
void CVector<T>::clear()
{
	if (maxSize>0)
	{
		delete[]pBuff;
		maxSize = len = 0;
		pBuff = nullptr;
	}
}
template<class T>
void CVector<T>::assign(size_t n, const T&elem)
{
	clear();
	if (n > 0)
	{
		pBuff = new T[n];
		len = maxSize = n;
		for (size_t i=0; i < len; i++)
		{
			pBuff[i] = elem;
		}
	}
}
template<class T>
T& CVector<T>::back()const
{
	return pBuff[len - 1];
}
template<class T>
T& CVector<T>::front()const
{
	return pBuff[0];
}
template<class T>
void CVector<T>::swap(CVector<T>&v1)
{
		CVector temp;
		temp.len = len;
		temp.maxSize = maxSize;
		temp.pBuff = pBuff;
		len = v1.len;
		maxSize = v1.maxSize;
		pBuff = v1.pBuff;
		v1.len = temp.len;
		v1.maxSize = temp.maxSize;
		v1.pBuff = temp.pBuff;
		temp.pBuff = nullptr;
		temp.len = temp.maxSize = 0;
}
template<class T>
bool CVector<T>::operator==(const CVector<T>&v1)
{
	if (len == v1.len&&v1.maxSize == maxSize)
	{
		for (size_t i = 0; i < len; i++)
		if (pBuff[i] != v1.pBuff[i])
			return false;
		return true;
	}
	else return false;
}
template<class T>
bool CVector<T>::operator!=(const CVector<T>&v1)
{
	if ((*this) == v1)
		return false;
	else
		return true;
}
template<class T>
bool CVector<T>::operator>(const CVector<T>&v1)
{
	size_t min_len = len > v1.len ? len : v1.len;
	for (size_t i = 0; i < min_len; i++)
	{
		if (pBuff[i] <= v1.pBuff[i])
		{
			return false;
		}
	}
	return true;
}
template<class T>
bool CVector<T>::operator>=(const CVector<T>&v1)
{
	if ((*this) > v1 || (*this) == v1) return true;
	else	return false;
}
template<class T>
bool CVector<T>::operator<(const CVector<T>&v1)
{
	if ((*this) > v1 || (*this) == v1) return false;
	else   return true;
}
template<class T>
bool CVector<T>::operator<=(const CVector<T>&v1)
{
	if ((*this) > v1 ) return false;
	else return true;
}
template<class T>
CVector<T>& CVector<T>::operator=(const CVector<T>&v1)
{
	clear();
	len = v1.len;
	maxSize = v1.maxSize;
	pBuff = new T[maxSize];
	for (size_t i = 0; i < len; i++)
	{
		pBuff[i] = v1.pBuff[i];
	}
	return(*this);
}
template<class T>
T CVector<T>::operator[](size_t index)
{
	return pBuff[index];
}
template<class T>
void CVector<T>::push_back(const T &elem)
{
	if (len < maxSize)
	{
		pBuff[len++] = elem;
	}
	else
	{
		maxSize += maxSize / 2>1 ? maxSize / 2 : 1;
		T*tempBuff;
		tempBuff = new T[maxSize];
		for (size_t i = 0; i < len; i++)
		{
			tempBuff[i] = pBuff[i];
		}
		delete[]pBuff;
		pBuff = tempBuff;
		tempBuff = nullptr;
		pBuff[len++] = elem;
	}
}
template<class T>
CVector<T>::~CVector()
{
	clear();
}
template<class T>
void CVector<T>::print()const
{
	for (size_t i = 0; i < len; i++)
	{
		cout << pBuff[i] << "\t";
	}
}
template<class T>
size_t CVector<T>::size()const
{
	return len;
}
template<class T>
size_t CVector<T>::max_size()const
{
	return maxSize;
}