之前看了一遍容器和迭代器，但听了学长说的，感觉我的理解有点偏差。打算来学习学习容器的具体用法，敲一敲。

先来学习顺序容器vector的用法。

类似于C风格的数组；元素内存空间连续，每个元素有自己的槽。在vector中可建立索引。可以在任何位置添加或删除新元素，需要线性时间。在尾部执行操作时，实际运行时间为摊还常量。（那么什么是摊还常量呢？）。随机访问单个元素的复杂度为常量时间。

概述

在vector头文件中被定义为一个带有2个类型参数的类模板：一个参数为要保存的元素类型，另一个参数为分配器（allocator)类型。

template <class T, class Allocator = allocator<T>> class vector;

Allocator参数指定内存分配器对象的类型，客户可设置内存分配器。（这章介绍的都是默认模板参数的内存分配器）

固定长度的vector

vector最简单的用法莫过于把它当做C风格数组的替代品（长度固定）。vector提供了一个可以指定元素数量的构造函数，还提供了重载的operator[]来访问和修改元素。

同时C++标准指出，通过operator[]来访问vector边界之外的元素，是UB。

除了使用operator[]运算符之外，还能用at(),front(),back()访问元素。

at() = operator[]，不过at()会检查边界，并在越界时抛出out_of_range。

front()和back()分别返回第一个元素和最后一个元素的引用。

下面敲一个来“标准化”考试分数的程序，经过标准化后，最高分100，其他所有分数据此调整。它创建了一个带有10个double值的vector，然后读入10个值，将每个值除以最高分，再乘以100，最后打印出新值。

vector<double> doubleVector(10);

double max = -numeric_limits<double>::infinity();

for(size_t i =0; i < doubleVector.size();i++){
    cout << "Enter score " << i+1 << ": ";
    cin >> doubleVector[i];
    if(doubleVector[i]>max){
        max = doubleVector[i];
    }
}

max /= 100.0;
for(auto& element: doubleVector){
    element /= max;
    cout << element << " ";
}

这里要注意的几点是：（1）.第一个for循环使用size()方法来确定容器元素的个数。

（2）.基于区间的for循环中用auto&而不是auto，因为这里要用引用，才能在每次迭代中修改元素。

动态长度的vector

vector真正好用之处在于它的动态增长。如前面的处理分数程序，如果要再加上一项任意数量的要求，那么则有：

vector<double> doubleVector;

double max = -numeric_limits<double>::infinity();

for(size_t i = 1; true; i++){
    double temp;
    cout << "Enter score " << i << "(-1 to stop)";
    cin >> temp;
    if(temp == -1) break;
    doubleVector.push_back(temp);
    if(temp > max) max = temp;
}

max /= 100.0;
for(auto& element: doubleVector){
    element/= max;
    cout << element << " ";
}

这创建了一个不包含元素的空vector，然后每读取一个值，通过push_back()方法添加到vector,push_back()能为新元素分配空间。基于区间的for循环不需要做修改。

详解

构造函数和析函数

默认的构造函数的创建一个不包含元素的vector

vector<int> intVector;

但也可以指定元素个数，并指定元素的值，如：vector<int> intVector(10,100)这个便指定了10个元素，初始化值为100

如果没有提供默认值，则对新对象进行0初始化。0初始化通过默认构造函数创建对象，将基本的整数类型初始化为0，浮点数0.0，指针类型nullptr。

还可以创建内建类的vector，如下所示：vector<string> stringVector(10,"Hello");

用户自定义的类也可：

class Element{
    public:
        Element(){}
        virtual ~Element() = default;
};
...
vector<Element> elementVector;

还可以用初始化列表：vector<int> intVector({1,2,3,4,5,6});。

initializer_list还可以用于统一初始化:

vector<int> intVector1 = {1,2,3,4,5,6};

vector<int> intVector2{1,2,3,4,5,6};

还可以在堆上分配:auto elementVector = make_unique<vector<Element>>(10);

复制和赋值

存储对象，其析构函数调用每个对象的析构函数。vector类的复制构造函数和赋值运算符对vector中的元素执行深赋值。所以，我们应该通过引用或者const引用向函数和方法传递vector来提高效率。

除了普通的复制和赋值运算符，还有assign()方法，删除所有元素，并添加任意树目的新元素。此方法适用于vector的重用。下面举个例子：intVector包含10个默认值为0的元素，然后通过assign()删除所有的10个元素，并以5个值为100的元素替代：

vector<int> intVector(10);
//other code
intVector.assign(5, 100);

而且assign还能接收initializer_list。现在intVector有4个具有给定值的元素：intVector.assign({1,2,3,4});

vector还提供了swap()方法，可以交换两个vector的内容，并且具有常量时间复杂度。举例：

vector<int> vectorOne(10);
vector<int> vectorTwo(5,100);
vectorOne.swap(vectorTwo);

比较

vector提供了：==,!=,<,>,<=,>=这6个重载的比较运算符。如果两个vector的元素数量相等，且对应元素也相等，那么2个vector相等。其比较用字典顺序（和字符串比较差不多）

下面是一个比较元素类型为int的两个vector的程序：

vector<int> vectorOne(10);
vector<int> vectorTwo(10);

if(vectorOnve == vectorTwo){
    cout << "equal!" << endl;
}else{
    cout << "not equal!"<< endl;
}

vectorOne[3] = 50;
if(vectorOne < vectorTwo){
    cout << "vectorOne is less than vectorTwo" << endl;
}else{
    cout <<"vectorTwo is not less than vectorTwo" << endl;
}

vector迭代器

先用迭代器将前面那个区间循环替代掉：

for(vector<double>::iterator iter = begin(doubleVector);
    iter != end(doubleVector); ++iter){
    *iter /= max;
    cout << *iter << " ";
}

这里: vector<double>::iterator iter = begin(doubleVector);。每个容器都定义了一种名为iterator的类型，来表示该容器类型的迭代器。begin()返回引用第一个元素的迭代器。

然后判断iter是否遇到了元素序列的尾部。++iter则是递增迭代器，以引用vector下一个元素。

循环体里面包含的两句。第一行通过*解除引用iter,从而获得iter引用的元素，然后给这个元素赋值。第二行再次解除引用，将元素流式输出到cout

可以通过auto来简化迭代器初始化：

for(auto iter = begin(doubleVector);
    iter != end(doubleVector); ++iter){
    ...
}

访问对象元素中的字段

如果迭代器是对象，那么可以通过->来调用对象的方法或者访问对象成员。如下列程序，建立了包含10个字符串的vector，然后遍历所有字符串，给每个字符串追加一个新的字符串：

vector<string> stringVector(10,"hello");
for(auto it = begin(stringVector);it != end(stringVector);++it){
    it->append(" there");
}

或者用基于区间的循环：

vector<string> stringVector(10,"hello");
for(auto& str : stringVector){
    str.append(" there");
}

const_iterator

正如const一样，对const对象调用begin和end，或者cbegin和cend，将会得到const_iterator。这是只读的，不能通过const_iterator修改元素。iterator始终可以转换为const_iterator。因此底下的行为是安全的：vector<type>::const_iterator it = begin(myVector);

然而，const_iterator不能转换为iterator.

在使用auto推断时，应该用cbegin和cend来返回const迭代器。基于区间也可以在区间元素前加const来强制使用const_iterator

迭代器的安全性

通常情况下，迭代器的安全性和指针接近：不安全。比如：

vector<int> intVector;
auto iter = end(intVector);
*iter = 10;

end()对空容器使用，返回的迭代器越过了尾部，试图解除引用会产生UB。（不会有检查的行为。）

如果使用了不匹配的迭代器，则可能出现其他UB行为：

vector<int> vectorOne(10);
vector<int> vectorTwo(10);

for(auto iter = begin(vectorTwo); iter != end(vectorOne); ++iter){
    //Loop body
}

其他迭代器操作

vector迭代器是随机访问的，因此可以自由前移、后移、跳跃。下列代码将第5个元素的值改为4：

vector<int> intVector(10);
auto it = begin(intVector);
it += 5;
--it;
*it = 4;

迭代器？索引？

前面写的功能更加用普通的索引也可以完成。那么为什么要用迭代器呢？

• 使用迭代器可以在任意位置 插入、删除元素或者元素序列。
• 迭代器可使用标准库算法。
• 通过迭代器顺序访问元素，通常比索引效率高（vector没有，但是list,map,set中效率提高）。

在vector中存储引用

需包含fuctional头文件，在容器中存储std::reference_wrapper。std::ref()和cref()用于创建非const和const reference_wrapper实例。

string str1 = "Hello";
string str2 = "World";

vector<reference_wrapper<string>> vec{ ref(str1) };
vec.push_back(ref(str2));

vec[1].get() += "!";

cout << str1 <<" "<< str2 << endl;

添加和删除元素

前面push_back可以向vector追加元素。还可以用pop_back()来删除元素。（它不会返回删除的元素，要返回得先调用back()来获得元素。）

通过insert()可以在任意位置插入元素，这个方法在迭代器指定位置添加一个或多个元素。它有5种重载形式：

• 插入单个元素
• 插入单个元素的n份副本
• 从某个迭代器范围插入元素。迭代器范围是半开区间，所以只包含初始迭代器，不包含尾部迭代器。
• 使用移动语义，将给定的元素转移到vector中，插入一个元素。
• 向vector中插入一列元素，这列元素是通过initializer_list指定。

通过erase()在vector中删除元素，clear()删除所有元素。erase有2个形式：1.单个迭代器，删除单个元素。2.2个迭代器，删除范围元素。

如果要删除满足条件的多个元素，以之前的想法是写个循环遍历所有元素。但这个方法有平方复杂度。可以使用删除-擦除惯用法(remove-erase-idiom)，线性复杂度。

• insert(const_iterator pos, const T& x):将x插入pos位置
• insert(const_iterator pos, size_type n, const T& x):将x 值在位置pos插入n次。
• insert(const_iterator pos, InputIterator first,InputIterator last):将[first,last)范围内的元素插入pos

template<typename T>
void printVector( const vector<T>& v){
    for(auto& element : v) {
        cout << element <<" ";
        cout << endl;
    }
}

vector<int> vectorOne = { 1, 2, 3, 4, 5};
vector<int> vectorTwo;

vectorOne.insert(cbegin(vectorOne)+3, 4);

for(int i = 6; i<=10; i++){
    vectorTwo.push_back(i);
}

printVector(vectorOne);
printVector(vectorTwo);

//Add all the elements from vectorTwo to the end of vectorOne
vectorOne.insert(cend(vectorOne),cbegin(vectorTwo),cend(vectorTwo));
printVector(vectorOne);

//now erase the numbers 2 through 5 in vectorOne
vectorOne.erase(cbegin(vectorOne)+1,cbegin(vectorOne)+5);
printVector(vectorOne);

//clear vectorTwo entirely
vectorTwo.clear();

//add 10 coples of the value 100
vectorTwo.insert(cbegin(vectorTwo), 10, 100);

//decide we only want 9 elements
vectorTwo.pop_back();
printVector(vectorTwo);

移动语义

所有的标准库容器都包含移动构造函数和移动赋值函数，从而实现移动语义。这样的一大好处是可以通过传值的方式从函数返回标准库容器，而不会降低性能。

vector<int> createVectorOfSize(size_t size)
{
    vector<int> vec(size);
    int contents = 0;
    for(auto& i : vec){
        i = contents++;
    }
    return vec;
}
...
vector<int> myVector;
myVector = createVectorOfSize(123);

如果没有移动语义，那么每次都进行防复制的话，性能会有很大影响。

push操作在某些情况下也会通过移动语义提升性能。例如，假如有一个类型为字符串的 vector，如下所示：

vector<string> vec

向这个vector添加元素，如下所示：

string myElement(5,'a') //construct the string"aaaaa"
vec.push_back(myElement);

由于myElement不是临时对象，所以pushback会生成其副本，然后存入vector。vector类还定义了push_back(const T& val)的移动版本。如果用move()，则可以避免这种复制：vec.push_back(move(myElement));。这之后，myElement处于有效但不确定状态，不应该再使用myElement。

也可以这样:vec.push_back(string(5,'a'));，string生成一个临时string对象，然后push_back将它直接move过去，避免了复制。

emplace操作

放置到位。

emplace_back()不会复制或移动任何数据，只是分配空间，然后就地构建对象。如：vec.emplace_back(5,'a')

emplace以可变参数模板的形式接收可变数目的参数。

从C++17开始，emplace_back()返回已插入元素的引用。在17之前，它的返回类型是void。

还有个emplace()方法，可以在指定位置就地构建对象，并返回所插入元素的迭代器。

算法复杂度和迭代器失效

在vector中插入或删除元素，会导致后面的所有元素向后移动，或向前移动。因此，它们都才用线性复杂度。此外，因为移动的原因，该点和其后的所有迭代器在操作完后都失效了。迭代器不会自己移动。

vector内部的重分配可能导致引用vector中元素的所有迭代器失效。！

内存分配方案

vector会自动分配内存来保存插如的元素。vector要求元素必须放在连续的内存，由于不可能请求在当前内存块的尾部追加内存，因此vector在申请更多内存时，要在另一个位置分配一块新的更大的内存块，然后将所有元素复制/移动到新的内存块。这很耗时，所以在执行重分配时，会分配比所需内存更多的内存，以尽量避免复制转移过程。

按道理，因为抽象原则，使用者不用考虑vector内部的内存分配方案，但是不然。

1).效率。vector分配方案能保证元素插入采用摊还常量时间复杂度：也就是说大部分操作都采用摊还常量，但是也有线性时间（需要重新分配内存），如果关注运行效率。那么可以控制vector执行内存重分配的时机。

2).迭代器失效。重分配会使引用vector内元素的所有迭代器失效。因此，vector接口允许查询或控制vector的重分配。如果不显式地控制重分配，那么应该假定每次插入都会导致重分配已经所有迭代器失效。

大小和容量

vector提供了两个可获得大小信息的方法:size()和capacity()

前者返回元素的个数，后者则返回重分配之前可以保存的元素个数。因此在重分配之前还能插入的元素个数为capacity()-size()

C++17中引入了非成员的std::size()和std::empty()全局函数。这些与用于获取迭代器的非成员函数类似（begin(),end()等）。非成员函数的size和empyt可以用于所有容器，也可以用于静态分配的C风格数组（不通过指针访问），以及initializer。

vector<int> vec{ 1,2,3 };
cout << size(vec) << endl;
cout << empty(vec) << endl;

预留容器

如果不关心效率和迭代器失效，那就不需要人为控制内存分配。但如果希望尽可能高效，或者确保迭代器不失效，就可以强制预先分配足够的空间，来保存所有元素。

另外一种方法是调用reserve()，负责分配保存指定数目元素的足够空间。

另外一种预分配空间的方法是在构造函数中，或者通过resize()或assign()方法，指定vector要保存的元素数目。会创建指定大小的vector。

直接访问数据

在内存中连续存储数据，可以用data()方法获取指向这块内存的指针。

C++17引入了非成员的data()来获取数据的指针。它可以用于array、vector容器、字符串、静态分配的C风格数组（不通过指针访问）和initializer_lists：

vector<int> vec{1,2,3};
int* data1 = vec.data();
int* data2 = data(vec);