C++标准库-vector

v e c t o r vector vector模塑出一个动态数组，是将元素存放在动态数组中加以管理的一个抽象概念。同时 C + + C++ C++标准库也并灭有规定必须以动态数组实现 v e c t o r vector vector。

v e c t o r vector vector是将元素复制到内部动态数组中。元素之间总是存在一定的顺序。所以 v e c t o r vector vector 是一种有序集合。它支持随机访问。

1、 v e c t o r vector vector大小与容量

v e c t o r vector vector提供了用于操作大小的函数有 s i z e ( ) , e m p t y ( ) size(),empty() size(),empty()和 m a x _ s i z e ( ) max\_size() max_size()，另一个和大小有关的函数 c a p a c i t y ( ) capacity() capacity()，返回 v e c t o r vector vector实际能够容纳的元素量。如果超过了这个量，就必须重新分配内部内存（这个过程非常耗时，而且重新分配之后以前的引用，指针和迭代都将失效）。

如果我们的程序管理了和 v e c t o r vector vector元素相关的引用，指针，迭代，亦或者是程序的运行速度对于我们来说非常重要，那么我们就必须考虑容量问题。

我们可以使用 r e s e r v e ( ) reserve() reserve()来保留适当的容量，避免重新分配存储（注意： r e s e r v e ( ) reserve() reserve()不能缩减容量，如果调用 r e s e r v e ( ) reserve() reserve()所给的实参小于当前容量，将不会引发任何效果）。同样，避免重新分配的另一个方法是，初始化期间就向构造函数传递额外实参，构造足够的空间 < v e c t o r > v ( e l e m ) <vector>v(elem) <vector>v(elem)，不过这种初始化很耗时。

现在我们来思考一个问题：如果你有一大堆的 v e c t o r vector vector，每个里面都存放少量的元素，这种浪费是相当可观的，我们要如何解决。

我们有一个间接缩减 v e c t o r vector vector的容量方法：两个 v e c t o r vector vector交换内容，他们的容量也会互换，因此来缩减容量。

vector<T> temp(V);
v.swap(temp);

但是 C + + 11 C++11 C++11引入了一个新函数：一个不据具强制力的要求，可以缩减容量以符合当前的元素个数 s h r i n k _ t o _ f i t ( ) shrink\_to\_fit() shrink_to_fit()，以便为实现可能的特有优化回旋余地。

vector<T> v1; //v1是一个空vector
vector<T> v2(v1); //v12中包含有v1中所有元素的副本
vector<T> v2 = v1;//等价于v2(v1)，v2中包含有v1的所有元素的副本
vector<T> v3(n, val);//包含n个重复的元素，每个元素的值都是val
vector<T> v4(n);//包含n个重复的执行了值初始化的对象
vector<T> v5{a,b,c....};//包含了初始化个数的元素，每个元素赋予相对应的初始值
vector<T> v5 = {a,b,c....};//等于上一个
v.`vector(); //销毁所有元素，释放内存

2、 v e c t o r vector vector容器内元素的访问

1、通过下标访问：

定义为 v e c t o r < T > v vector<T> v vector<T>v 的 v e c t o r vector vector容器，可以使用 v [ 0 ] 、 v [ 1 ] 、 v [ 2 ] . . . v[0]、v[1]、v[2]... v[0]、v[1]、v[2]...这种方式来访问。当然，下标不能越界( v . s i z e ( ) − 1 v.size()-1 v.size()−1之内)。其等价于 ∗ ( v . b e g i n ( ) ) 、 ( v . b e g i n ( ) + 1 ) 、 ( v . b e g i n ( ) + 2 ) *(v.begin() )、(v.begin() + 1)、(v.begin() + 2) ∗(v.begin())、(v.begin()+1)、(v.begin()+2)。

2、通过迭代器来访问：

迭代器( i t e r a t o r iterator iterator)可以理解为一种类似指针的东西，其定义是： v e c t o r < T > : : i t e r a t o r i t vector<T>::iterator\ it vector<T>::iterator it;

这样就得到了迭代器 i t it it，并且可以通过 ∗ i t *it ∗it 来访问 v e c t o r vector vector里的元素。

访问方式：

#include "iostream"
using namespace std;
int main(){
	vector<int> v={1,2,3};
	for(vector<int>::iterator it = v.begin(); it != v.end(); it++){
		cout << *it << " ";//输出1，2，3
	}
    return 0;
}

3、 v e c t o r vector vector常用函数实例解析

v . p u s h _ b a c k ( e l e m ) v.push\_back(elem) v.push_back(elem)：在尾部加入一个数据
v . p o p _ b a c k ( ) v.pop\_back() v.pop_back()：删除最后一个数据
v . a t ( i d x ) v.at(idx) v.at(idx)：返回索引 i d x idx idx所指向的数据，若 i d x idx idx越界，抛出 o u t _ o f _ r a n g e out\_of\_range out_of_range。
v . b a c k ( ) v.back() v.back()：传回最后一个数据，不检查这个数据是否存在
v . f r o n t ( ) v.front() v.front()：传回第一个数据，不检查这个数据是否存在
v . b e g i n ( ) v.begin() v.begin()：传回迭代器中的第一个数据地址
v . e n d ( ) v.end() v.end()：传回迭代器中的末端元素的下一个位置
v . c a p a c i t y ( ) v.capacity() v.capacity()：返回不进行空间重新分配下的元素最大容量
v . s i z e ( ) v.size() v.size()：返回容器中元素的个数
v . c l e a r ( ) v.clear() v.clear()：删除容器中的所有元素
v . e m p t y ( ) v.empty() v.empty()：判断容器是否为空
v . s h r i n k _ t o _ f i t ( ) v.shrink\_to\_fit() v.shrink_to_fit()：降低容量，以符合元素个数
v . e r a s e ( p o s ) v.erase(pos) v.erase(pos)：删除pos位置上的元素，返回下一个元素的位置
v . e r a s e ( b e g , e n d ) v.erase(beg, end) v.erase(beg,end)：删除 [ b e g , e n d ) [beg,end) [beg,end)区间上的元素，返回下一个元素的位置
v . i n s e r t ( p o s , e l e m ) v.insert(pos, elem) v.insert(pos,elem)：在 p o s pos pos的位置上插入一个 e l e ele ele元素，返回新元素位置
v . i n s e r t ( p o s , n , e l e m ) v.insert(pos, n, elem) v.insert(pos,n,elem)：在 p o s pos pos的位置上插入 n n n个 e l e m elem elem元素，返回第一个新元素地址
v . i n s e r t ( p o s , b e g , e n d ) v.insert(pos, beg, end) v.insert(pos,beg,end)：在 p o s pos pos的位置上插入 [ b e g , e n d ) [beg,end) [beg,end)区间上的元素，返回第一个新元素地址
v . m a x _ s i z e ( ) v.max\_size() v.max_size()：返回容器中元素个数可能的最大容量
v . r b e g i n ( ) v.rbegin() v.rbegin()：传回一个逆向队列的第一个数据
v . r e n d ( ) v.rend() v.rend()：传回一个逆向队列的最后一个数据的下一个位置
v . r e s e r v e ( n u m ) v.reserve(num) v.reserve(num)：重新指定队列的长度
v . s w a p ( v e ) v.swap(ve) v.swap(ve)：将它们之间的元素互换
v . a s s i g n ( n , e l e m ) v.assign(n,elem) v.assign(n,elem)：赋值 n n n个 e l e m elem elem，赋值给 v v v
v . a s s i g n ( b e g , e n d ) v.assign(beg,end) v.assign(beg,end)：将区间 [ b e g , e n d ) [beg,end) [beg,end)内的所有元素赋值给 v v v

星*湖