Vector容器详细总结

$注：以下所说的函数以及代码都是在C++11下进行的$

一：什么是Vector

向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。

二：C++通过构造函数初始化的方式（常用）

1. vector():创建一个空vector
2. vector(int nSize):创建一个vector,元素个数为nSize
3. vector(int nSize,const t& t):创建一个vector，元素个数为nSize,且值均为t
4. vector(const vector&):复制构造函数
5. vector(begin,end):复制[begin,end)区间内另一个数组的元素到vector中

#include <iostream>
#include <vector>
using namespace std;
int main(){
    vector<int>first;   //定义一个向量，大小为0。
    vector<int>second(100);  //定义一个向量，大小为100，默认值为0
    vector<int>third(4,100);   //定义一个向量，大小为4，值都是100
    vector<int>forth(third.begin()+1,third.end());  //将第三个数组区间[begin+1,end]复制给forth
    vector<int>fifth(forth); //将第四个数组复制构造给fifth

    int array[] = {1,2,3,4};
    vector<int>sixth(array,array+sizeof(array));  //通过数组复制构造
    vector<int>seventh = {1,2,3,4,5,6};  //ilist 初始化为列表中元素的拷贝，列表中元素必须与ilist的元素类型相容，本例中必须是与整数类型相容的类型，整形会直接拷贝，其他类型会进行类型转换。
    
    return 0;
}

其他的构造方法详见官方文档：C++vector

三：vector常用方法

首先粗略的看下官方文档中所给的方法：

下面具体讲解其中比较常用的方法

1. assign
   1. void assign (InputIterator first, InputIterator last);
   2. void assign (size_type n, const value_type& val);
   3. void assign (initializer_list<value_type> il);

第一种:
vector<int>first;
vector<int>second(100);
first.assign(second.begin(),second.end());
ouput:100个0

第二种:
vector<int>first;
first.assign(10,9);
output:9999999999

第三种:
vector<int>first;
first.assign({1,2,3,4,5,6,7,8,9});
output:123456789

2. vector.begin();

Returns an iterator pointing to the first element in the vector.
返回指向向量中第一个元素的迭代器。

3. vector.end();

Returns an iterator referring to the past-the-end element in the vector container.

4. vector.push_back();

Adds a new element at the end of the vector, after its current last element. The content of val is copied (or moved) to the new element.
在向量的最后一个元素后面添加一个新元素。val的内容被复制（或移动）到新元素中。

vector<int>a;       //a现在为空
a.push_back(1)；    // a现在为{1}；

5. vector.pop_back();

Removes the last element in the vector, effectively reducing the container size by one.
This destroys the removed element.
移除向量中的最后一个元素，将容器大小减少一个。
移除的元素将会被销毁

vector<int>a() = {1,2,3,4};
a.pop_back();   //a现在为{1，2，3}

6. vector.size()

返回容器的大小

vector<int>a() = {1,2,3,4};
a.size();   //4

7. size,capacity,resize,reserve,max_size函数的理解
8. vector.clear();

清空向量，向量大小size设为0，capacity不变

vector<int>a() = {1,2,3,4};
vector.clear();
a.size();   //4

9. vector.swap(vector& x)

Exchanges the content of the container by the content of x, which is another vector object of the same type. Sizes may differ.
通过x的内容交换容器的内容，x是另一个相同类型的向量对象。尺寸不一定要相同。

vector<int>a(3,20)  //a现在是{20，20，20}
vector<int>b(2,30)  //b现在是{30，30}
a.swap(b);  //a现在是{30，30}，b现在是{20，20，20}

10. vector::operator=

Assigns new contents to the container, replacing its current contents, and modifying its size accordingly.
将新内容指派给容器，替换其当前内容，并相应地修改其大小。

vector<int>a = {1,2,3,4,5}; a通过“=”获得了值{1，2，3，4，5}
vector<int>b = a;   b通过“=”获得了a的值{1，2，3，4，5}

11. vector.empty();

Returns whether the vector is empty (i.e. whether its size is 0).
判断是否为空，是就返回“true"，不是就返回"false"

这个并不是清空vector，清空是vector.clear();

vector<int>a;
a.empty(); //true;
a.push_back(1);
a.empty(); //false;

12. vector.at(n)

Returns a reference to the element at position n in the vector.
返回向量在n位置的元素

与” [ ] "不同的地方是，at会自动判定n是否越界，并会抛出out of range的异常，“ [ ] "不会。

vector<int>a;   //a现在为空
for (unsigned i=0; i<10; i++)
    a.at(i)=i;
 //a现在为{1，2，3，4，5，6，7，8，9}

13. vector.rease(n) / vector.rease(begin,last)
    删除向量的第n个元素或者是删除向量的[begin,last]之间的元素。

Removes from the vector either a single element (position) or a range of elements ([first,last)).

This effectively reduces the container size by the number of elements removed, which are destroyed.

Because vectors use an array as their underlying storage, erasing elements in positions other than the vector end causes the container to relocate all the elements after the segment erased to their new positions. This is generally an inefficient operation compared to the one performed for the same operation by other kinds of sequence containers (such as list or forward_list).

14. vector.front();

返回向量中第一个元素的引用，更改vector.front()的值可以直接改变向量的值

vector<int> myvector;

myvector.push_back(78);
myvector.push_back(16);
// now front equals 78, and back 16，myvector为{78，16}
myvector.front() -= myvector.back();
// now front equals 62, and back 16，myvector为{62，16}

15. vector.back();

返回向量最后一个元素的引用，更改vector.back()的值可以直接改变向量的值

begin(),end(),front(),back()的区别
16.insert

1. iterator insert (const_iterator position, const value_type& val);
2. iterator insert (const_iterator position, size_type n, const value_type& val);
3. iterator insert (const_iterator position, InputIterator first, InputIterator last);
4. iterator insert (const_iterator position, value_type&& val);
5. iterator insert (const_iterator position, initializer_list<value_type> il)

注意：insert的返回值是一个指向所插入的元素的第一个元素的迭代器

// inserting into a vector
#include <iostream>
#include <vector>

int main ()
{
    std::vector<int> myvector (3,100);
    std::vector<int>::iterator it;

    it = myvector.begin();
    it = myvector.insert ( it , 200 );
    std::cout<<*it;
    myvector.insert (it,2,300);

    // "it" no longer valid, get a new one:
    it = myvector.begin();

    std::vector<int> anothervector (2,400);
    myvector.insert (it+2,anothervector.begin(),anothervector.end());

    int myarray [] = { 501,502,503 };
    myvector.insert (myvector.begin(), myarray, myarray+3);

    std::cout << "myvector contains:";
    for (it=myvector.begin(); it<myvector.end(); it++)
        std::cout << ' ' << *it;
    std::cout << '\n';

    return 0;
}

17. To be continue…