c++的标准模板库之Vector篇

Vector(向量)

Vector可以说是我们解决线上OJ或者说其他管理过程中最方便的STL之一，也基本上是使用的最多的一种，本期就带大家来看看我们的Vector到底都能干什么。
剧透一下，本篇以函数及其用法为主，非常通俗易懂。

概念

顺序容器, 起始端封闭, 结尾端开放, 可从结尾处或内部进行插入, 储存在<>中定义的类型的元素, 可以理解为一个数组的强化版(可以动态扩容), 具有模板的基本功能.

一些内部函数

函数名	作用	返回值(类型)
.begin()	返回当前容器第一个元素的迭代器(指针)	vector<存储类型>::iterator
.end()	返回当前容器最后一个元素之后的的迭代器(指针)	vector<存储类型>::iterator
.rbegin()	返回最后一个元素的迭代器(指针)	vector<存储类型>::iterator
.rend()	返回第一个元素之前的迭代器(指针)	vector<存储类型>::iterator
.push_back()	在容器右端添加元素	无
.pop_back()	在容器右端取出元素	无
.insert()	插入元素	vector<存储类型>::iterator
.front()	获取当前容器第一个元素的引用(值)	容器所存类型
.back()	获取当前容器最后一个元素的引用(值)	容器所存类型
.Size()	获取当前容器的长度	Size_t
.max_Size()	获取当前容器所能储存的最大长度	Size_t
.erase()	删除容器元素	无
.clear()	清空容器	无
.empty()	判断当前容器是否为空	bool
.capacity()	获取当前容器在不再次扩容的情况下的容量	Size_t
at(int n)	返回下标为n的元素	容器所存类型
swap()	交换两个容器	容器
operator[int n]	重载[]符号，让vector对象也能使用	容器所存类型

对于大多简单的用法,就不在下面赘述,这里简单提

void test()
{
	vector<char> v1;//对象v1
	vector<char>::iterator vit;//迭代器
	v1.push_back('a');//在容器右端添加元素(长度为4)
	v1.push_back('b');
	v1.push_back('c');
	v1.push_back('d');


	for (vector<char>::iterator vit = v1.begin(); vit != v1.end(); vit++)
	{
		cout << *vit << " ";
	}
	cout << endl;


	v1.pop_back();//在容器右端取出元素(长度为3)
	for (vector<char>::iterator vit = v1.begin(); vit != v1.end(); vit++)
	{
		cout << *vit << " ";
	}
	cout << endl;


	//cout << v1.size() << endl;//获取当前容器的长度
	size_t t = size(v1);
	cout << t << endl;


	t = v1.max_size();//获取当前容器所能储存的最大长度
	cout << t << endl;

	//cout << v1.front() << endl;//获取当前容器第一个元素的引用(值)
	char t1 = v1.front();
	cout << t1 << endl;

	t1 = v1.back();//获取当前容器最后一个元素的引用(值)
	cout << t1 << endl;


	t = v1.capacity();//获取当前容器在不再次扩容的情况下的容量
	cout << t << endl;

	vit = v1.begin();//返回当前容器第一个元素的迭代器(指针)
	cout << *vit << endl;

	vit = v1.end();//返回当前容器最后一个元素之后的迭代器(指针)
	cout << *(vit - 1) << endl;

	cout << v1.empty() << endl;//判断当前对象是否为空,是为true

	cout << v1.at(1) << endl;//返回下标为1的元素

	cout << v1[1] << endl;//运算符[]的重载

}

构造

vector <类型> v //默认构造

vector <类型> v(const vector<类型> & V) //拷贝构造

vector <类型> v (v1.begin(), v1.end()) //区间构造

vector <类型> v (int n, element) //元素构造

void test1()
{
	vector<char> v;                                                          //默认构造
	v.push_back('a');
	v.push_back('b');
	v.push_back('c');
	v.push_back('d');
	v.push_back('e');
	v.push_back('f');
	v.push_back('g');
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i];
	}
	cout << endl;
	vector<char> v1(v.begin()+1, v.begin()+5);        //区间构造,里面的参数必须为迭代器类型
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1[i];
	}
	cout << endl;
	vector<char> v2(v1);                                               //拷贝构造
	for (int i = 0; i < v2.size(); i++)
	{
		cout << v2[i];
	}
	cout << endl;
	vector<char> v3(5, 'a');                                             //元素构造
	for (int i = 0; i < v3.size(); i++)
	{
		cout << v3[i];
	}
	cout << endl;
}

元素插入与删除

插入的 insert 函数可以实现多位置插入

而删除时可以使用 erase 函数和 clear 函数

void test2()
{
	vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i]<<' ';
	}
	cout << endl;
	v.insert(v.begin(), 666);                          //在v.begin这个迭代器之前加上"666"
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i]<<' ';
	}
	cout << endl;
	v.erase(v.begin());                                      //删除v.begin()所指向的元素
	v.insert(v.begin() + 1, 3, 5);                         //在v.begin() + 1之前插入3个5
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << ' ';
	}
	cout << endl;
	v.erase(v.begin() + 1, v.begin() + 4);            //删除这个区间的数据,区间为左闭右开
	vector <int>v1 = { 1,2,3 };
	v.insert(v.end(), v1.begin(), v1.end());             //在v的末端插入v1的元素
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << ' ';
	}
	cout << endl;
	v.clear();//比较暴力,清除所有元素,但是删除前后capacity不会变
	cout << v.empty() << endl;
}

赋值和开辟空间,置换

赋值有三种方法(建立在已经创建对象之后):

1. v1=v2 //operator=
2. v.assign(v1.begin(),v1.end()) //区间赋值
3. v.assign(int n, element) //n个element

void test3()
{
	vector <int> v;
	cout << v.capacity() << endl;
	v.reserve(10000);                        //对象会不断扩容会比较麻烦,一次扩容比较方便
	cout << v.capacity() << endl;
	for (int i = 0; i < 10000; i++)                    //这时容量很大
	{
		v.push_back(i);
	}
	v.resize(3);                            //重新定义长度之后,容量没有变化,还是很大
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << ' ';
	}
	cout << endl;
	vector <int>(v).swap(v);                       //用匿名对象交换容量后进行销毁
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << ' ';
	}
	cout << endl;
	v.resize(10, 6);      //再次重新定义长度,当第二个参数没有给到的时候,会默认将超出的长度定义为0
    for (int i = 0; i < v.size(); i++)
    {
        cout << v[i] << ' ';
    }
    cout << endl;
}