STL之vector使用简介

Vector成员函数

函数	表述
c.assign(beg,end) c.assign(n,elem)	将[beg; end)区间中的数据赋值给c。 将n个elem的拷贝赋值给c。
c.at(idx)	传回索引idx所指的数据，如果idx越界，抛出out_of_range。
c.back()	传回最后一个数据，不检查这个数据是否存在。
c.begin()	传回迭代器重的可一个数据。
c.capacity()	返回容器中数据个数。
c.clear()	移除容器中所有数据。
c.empty()	判断容器是否为空。
c.end()	指向迭代器中的最后一个数据地址。
c.erase(pos) c.erase(beg,end)	删除pos位置的数据，传回下一个数据的位置。 删除[beg,end)区间的数据，传回下一个数据的位置。
c.front()	传回第一个数据。
get_allocator	使用构造函数返回一个拷贝。
c.insert(pos,elem) c.insert(pos,n,elem) c.insert(pos,beg,end)	在pos位置插入一个elem拷贝，传回新数据位置。 在pos位置插入n个elem数据。无返回值。 在pos位置插入在[beg,end)区间的数据。无返回值。
c.max_size()	返回容器中最大数据的数量。
c.pop_back()	删除最后一个数据。
c.push_back(elem)	在尾部加入一个数据。
c.rbegin()	传回一个逆向队列的第一个数据。
c.rend()	传回一个逆向队列的最后一个数据的下一个位置。
c.resize(num)	重新指定队列的长度。
c.reserve()	保留适当的容量。
c.size()	返回容器中实际数据的个数。
c1.swap(c2) swap(c1,c2)	将c1和c2元素互换。 同上操作。
vector<Elem> c vector <Elem> c1(c2) vector <Elem> c(n) vector <Elem> c(n, elem) vector <Elem> c(beg,end) c.~ vector <Elem>()	创建一个空的vector。 复制一个vector。 创建一个vector，含有n个数据，数据均已缺省构造产生。 创建一个含有n个elem拷贝的vector。 创建一个以[beg;end)区间的vector。 销毁所有数据，释放内存。

 

vector声明及初始化

vector<int> vec;        //声明一个int型向量
vector<int> vec(5);     //声明一个初始大小为5的int向量
vector<int> vec(10, 1); //声明一个初始大小为10且值都是1的向量
vector<int> vec(tmp);   //声明并用tmp向量初始化vec向量
vector<int> tmp(vec.begin(), vec.begin() + 3);  //用向量vec的第0个到第2个值初始化tmp
int arr[5] = {1, 2, 3, 4, 5};   
vector<int> vec(arr, arr + 5);      //将arr数组的元素用于初始化vec向量
vector<int> vec(&arr[1], &arr[4]); //将arr[1]~arr[4]范围内的元素作为vec的初始值

vector基本操作

(1) 容量

向量大小： vec.size();

向量最大容量： vec.max_size();

更改向量大小： vec.resize();

向量真实大小： vec.capacity();

向量判空： vec.empty();

减少向量大小到满足元素所占存储空间的大小： vec.shrink_to_fit(); //shrink_to_fit

(2) 修改

多个元素赋值： vec.assign(); //类似于初始化时用数组进行赋值

末尾添加元素： vec.push_back();

末尾删除元素： vec.pop_back();

任意位置插入元素： vec.insert();

任意位置删除元素： vec.erase();

交换两个向量的元素： vec.swap();

清空向量元素： vec.clear();

(3)迭代器

开始指针：vec.begin();

末尾指针：vec.end(); //指向最后一个元素的下一个位置

指向常量的开始指针： vec.cbegin(); //意思就是不能通过这个指针来修改所指的内容，但还是可以通过其他方式修改的，而且指针也是可以移动的。

指向常量的末尾指针： vec.cend();

(4)元素的访问

下标访问： vec[1]; //并不会检查是否越界

at方法访问： vec.at(1); //以上两者的区别就是at会检查是否越界，是则抛出out of range异常

访问第一个元素： vec.front();

访问最后一个元素： vec.back();

返回一个指针： int* p = vec.data(); //可行的原因在于vector在内存中就是一个连续存储的数组，所以可以返回一个指针指向这个数组。这是是C++11的特性。

(5)算法

遍历元素

vector<int>::iterator it; 
for (it = vec.begin(); it != vec.end(); it++) coutendl; //或者forsize_t0; i < vec.size(); i++) { coutendl; }

元素翻转

#include <algorithm>
reverse(vec.begin(), vec.end());

元素排序

#include <algorithm>
sort(vec.begin(), vec.end()); //采用的是从小到大的排序
//如果想从大到小排序，可以采用上面反转函数，也可以采用下面方法:
bool Comp(const int& a, const int& b) {
return a > b;
}
sort(vec.begin(), vec.end(), Comp);

vector对象最重要的几种操作

1. v.push_back(t) 在容器的最后添加一个值为t的数据，容器的size变大。

另外list有push_front()函数，在前端插入，后面的元素下标依次增大。

2. v.size() 返回容器中数据的个数，size返回相应vector类定义的size_type的值。v.resize(2*v.size)或v.resize(2*v.size, 99)将v的容量翻倍(并把新元素的值初始化为99)

3. v.empty() 判断vector是否为空

4. v[n] 返回v中位置为n的元素

5. v.insert(pointer,number, content) 向v中pointer指向的位置插入number个content的内容。

还有v. insert(pointer, content)，v.insert(pointer,a[2],a[4])将a[2]到a[4]三个元素插入。

6. v.pop_back() 删除容器的末元素，并不返回该元素。

7.v.erase(pointer1,pointer2)删除pointer1到pointer2中间（包括pointer1所指）的元素。

vector中删除一个元素后，此位置以后的元素都需要往前移动一个位置，虽然当前迭代器位置没有自动加1，但是由于后续元素的顺次前移，也就相当于迭代器的自动指向下一个位置一样。

8. v1==v2 判断v1与v2是否相等。

9. ！=、<、<=、>、>= 保持这些操作符惯有含义。

10.vector<typeName>::iteratorp=v1.begin( ); p初始值指向v1的第一个元素。*p取所指向元素的值。 对于const vector<typeName>只能用vector<typeName>::const_iterator类型的指针访问。

11. p=v1.end( );p指向v1的最后一个元素的下一位置。

12.v.clear() 删除容器中的所有元素。12.v.clear() 删除容器中的所有元素。

 

#include<algorithm>中的泛函算法

搜索算法：find() 、search() 、count() 、find_if() 、search_if() 、count_if()

分类排序：sort() 、merge()

删除算法：unique() 、remove()

生成和变异：generate() 、fill() 、transformation() 、copy()

关系算法：equal() 、min() 、max()

sort(v1.begin(),vi.begin()+v1.size/2）; 对v1的前半段元素排序

list<char>::iterator pMiddle =find(cList.begin(),cList.end(),'A');找到则返回被查内容第一次出现处指针，否则返回end()。

vector< typeName >::size_typex ; vector< typeName >类型的计数，可用于循环如同for(int i)

 

内存管理与效率

1.使用reserve()函数提前设定容量大小，避免多次容量扩充操作导致效率低下。

关于STL容器，最令人称赞的特性之一就是是只要不超过它们的最大大小，它们就可以自动增长到足以容纳你放进去的数据。（要知道这个最大值，只要调用名叫max_size的成员函数。）对于vector和string，如果需要更多空间，就以类似realloc的思想来增长大小。vector容器支持随机访问，因此为了提高效率，它内部使用动态数组的方式实现的。在通过 reserve() 来申请特定大小的时候总是按指数边界来增大其内部缓冲区。当进行insert或push_back等增加元素的操作时，如果此时动态数组的内存不够用，就要动态的重新分配当前大小的1.5~2倍的新内存区，再把原数组的内容复制过去。所以，在一般情况下，其访问速度同一般数组，只有在重新分配发生时，其性能才会下降。正如上面的代码告诉你的那样。而进行pop_back操作时，capacity并不会因为vector容器里的元素减少而有所下降，还会维持操作之前的大小。对于vector容器来说，如果有大量的数据需要进行push_back，应当使用reserve()函数提前设定其容量大小，否则会出现许多次容量扩充操作，导致效率低下。

 

reserve成员函数允许你最小化必须进行的重新分配的次数，因而可以避免真分配的开销和迭代器/指针/引用失效。但在我解释reserve为什么可以那么做之前，让我简要介绍有时候令人困惑的四个相关成员函数。在标准容器中，只有vector和string提供了所有这些函数。

(1)size()告诉你容器中有多少元素。它没有告诉你容器为它容纳的元素分配了多少内存。

(2)capacity()告诉你容器在它已经分配的内存中可以容纳多少元素。那是容器在那块内存中总共可以容纳多少元素，而不是还可以容纳多少元素。如果你想知道一个vector或string中有多少没有被占用的内存，你必须从capacity()中减去size()。如果size和capacity返回同样的值，容器中就没有剩余空间了，而下一次插入（通过insert或push_back等）会引发上面的重新分配步骤。

(3)resize(Container::size_type n)强制把容器改为容纳n个元素。调用resize之后，size将会返回n。如果n小于当前大小，容器尾部的元素会被销毁。如果n大于当前大小，新默认构造的元素会添加到容器尾部。如果n大于当前容量，在元素加入之前会发生重新分配。

(4)reserve(Container::size_type n)强制容器把它的容量改为至少n，提供的n不小于当前大小。这一般强迫进行一次重新分配，因为容量需要增加。（如果n小于当前容量，vector忽略它，这个调用什么都不做，string可能把它的容量减少为size()和n中大的数，但string的大小没有改变。在我的经验中，使用reserve来从一个string中修整多余容量一般不如使用“交换技巧”，那是条款17的主题。）