C++ vector容器注意事项

容量（capacity）和大小（size）的区别

vector 容器的容量（用 capacity 表示），指的是在不分配更多内存的情况下，容器可以保存的最多元素个数；而 vector 容器的大小（用 size 表示），指的是它实际所包含的元素个数。

对于一个 vector 对象来说，通过该模板类提供的 capacity() 成员函数，可以获得当前容器的容量；通过 size() 成员函数，可以获得容器当前的大小。例如：

#include 
#include 
using namespace std;
int main()
{
    std::vector<int>value{ 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47 };
    value.reserve(20);
    cout << "value 容量是：" << value.capacity() << endl;
    cout << "value 大小是：" << value.size() << endl;
    return 0;
}

程序输出结果为：

value 容量是：20
value 大小是：15

结合该程序的输出结果，下图可以更好的说明 vector 容器容量和大小之间的关系：

显然，vector 容器的大小不能超出它的容量，在大小等于容量的基础上，只要增加一个元素，就必须分配更多的内存。注意，这里的“更多”并不是 1 个。换句话说，当 vector 容器的大小和容量相等时，如果再向其添加（或者插入）一个元素，vector 往往会申请多个存储空间，而不仅仅只申请 1 个。

一旦 vector 容器的内存被重新分配，则和 vector 容器中元素相关的所有引用、指针以及迭代器，都可能会失效，最稳妥的方法就是重新生成。

vector的原理

简单来说就是，每个vector都分配有一定容量，当存储的数据达到容量的上限的时候，就重新分配内存。vector类内部包含三个迭代器：

private:
	iterator _start;
	iterator _last;
	iterator _endofstorage;

vector扩容的本质

vector 容器扩容的过程需要经历以下 3 步：

1. 申请更大的内存空间（VS2019中以1.5倍扩容，GCC以2倍扩容）；
2. 将旧内存空间中的数据，按原有顺序移动到新的内存空间中；
3. 最后将旧的内存空间释放。

由此可见，vector 扩容是非常耗时的。为了降低再次分配内存空间时的成本，每次扩容时 vector 都会申请比用户需求量更多的内存空间（这也就是 vector 容量的由来，即 capacity>=size），以便后期使用。

为什么容器扩容为原来的1.5倍或者2倍

为什么要成倍的扩容而不是一次增加一个固定大小的容量

假定有 n 个元素,倍增因子为 m，则：

1. 完成这 n 个元素往一个 vector 中的 push_back​操作，需要重新分配内存的次数大约为 logm(n)

2. 第 i 次重新分配将会导致复制 m^(i) (也就是当前的vector.size() 大小)个旧空间中元素

3. n 次 push_back 操作所花费的时间复制度为O(n)

4. m / (m - 1)是一个常量，均摊分析的方法可知，vector 中 push_back 操作的时间复杂度为常量时间

假设vector的容量一次增加固定值大小，则：

1. 假定有 n 个元素,每次增加k个。
2. 第i次增加复制的数量为为：100i。
3. n 次 push_back 操作所花费的时间复杂度为O(n^2)。

4. 均摊下来每次push_back 操作的时间复杂度为O(n)。

为什么是以2倍或1.5倍的方式扩容而不是其他倍数

根据查阅的资料显示，考虑可能产生的堆空间浪费，成倍增长倍数不能太大，使用较为广泛的扩容方式有两种，以2二倍的方式扩容，或者以1.5倍的方式扩容。以2倍的方式扩容，导致下一次申请的内存必然大于之前分配内存的总和，导致之前分配的内存不能再被使用，所以最好倍增长因子设置为(1,2)之间，即：

用一张图来说明2倍扩容与1.5倍扩容的区别：

使用2倍（k=2）扩容机制扩容时，每次扩容后的新内存大小必定大于前面的总和。而使用1.5倍（k=1.5)扩容时，在几次扩展以后，可以重用之前的内存空间了。

vector的clear方法

vector.clear()函数并不会把所有元素清零，vector.clear()的真正作用是：把size设置成0，capacity不变。

vector有两个参数，一个是size，表示当前vector容器内存储的元素个数，一个是capacity，表示当前vector在内存中申请的这片区域所能容纳的元素个数。

通常capacity会比size大，如果往vector中push_back数据，这样就不用重新申请内存和拷贝元素到新内存区域了，便于节省时间。

vector的erase方法

erase函数可以用于删除vector容器中的一个或者一段元素，在删除一个元素的时候，其参数为指向相应元素的迭代器，而在删除一段元素的时候，参数为指向一段元素的开头的迭代器以及指向结尾元素的下一个元素的迭代器。

在进行单个元素删除后，传入的迭代器指向不变，仍然指向被删除元素的位置，而被删除元素之后的所有元素都向前移动一位，也就是该迭代器实际上是指向了原来被删除元素的下一个元素。删除一段元素后，传入的迭代器指向也是不变的，仍然指向原来传进去时候的位置，修改的是删除段后面的元素的位置。
erase共三种用法：

erase(pos,n);
删除从下标pos开始的n个字符，比如erase(0,1)就是删除第一个字符

erase(position);
删除postion处的一个字符（position是一个string类型的迭代器）

erase(first,last)
删除从first到last之间的字符（first和last都是迭代器）

缩减容量/内存释放

在C++标准库容器vector的容量是不会自动的缩减的，也就是说删除元素操作，其引用、指针、迭代器也会继续有效。那么当在一个较大的vector中删除了大量的元素之后，其实际的size比较小，而其capacity比较大，如果对空间比较敏感，希望vector的容量能够缩小一些，这时要重新产生一个小数组，并用swap()与原数组交换，如下所示：

//v已经在前面进行了一些增删操作，在进行下面的操作，就可以缩小容量
std::vector<T> tmp(v);
tmp.swap(v);

或者

std::vector<T>(v1).swap(v1);

这依赖于以下事实：vector的复制构造函数仅分配要复制的元素所需的内存。

empty()用来检测容器是否为空的，clear()可以清空所有元素。但是即使clear()，vector所占用的内存空间依然如故，无法保证内存的回收，vector需要使用swap()来释放内存，具体方法如下：

vector<int> nums; 
nums.push_back(1);
nums.push_back(1);
nums.push_back(2);
nums.push_back(2); 
vector<int>().swap(nums); //或者nums.swap(vector ())

或者如下所示，使用一对大括号，意思一样的：

//加一对大括号是可以让tmp退出{}的时候自动析构
{ 
    std::vector<int> tmp =   nums;  
    nums.swap(tmp); 
}

emplace_back()和push_back()的区别

vector中可以用来从容器末尾添加元素的函数有 2 个，分别是 push_back() 和 emplace_back() 函数。

push_back()函数的功能是在 vector 容器尾部添加一个元素，用法也非常简单，比如：

#include 
#include 
using namespace std;
int main()
{
    vector<int> values{};
    values.push_back(1);
    values.push_back(2);
    for (int i = 0; i < values.size(); i++) {
        cout << values[i] << " ";
    }
    return 0;
}

运行程序，输出结果为：

1 2

emplace_back()函数是 C++ 11 新增加的，其功能和 push_back() 相同，都是在 vector 容器的尾部添加一个元素。

emplace_back() 成员函数的用法也很简单，这里直接举个例子：

#include 
#include 
using namespace std;
int main()
{
    vector<int> values{};
    values.emplace_back(1);
    values.emplace_back(2);
    for (int i = 0; i < values.size(); i++) {
        cout << values[i] << " ";
    }
    return 0;
}

运行结果为：

1 2

emplace_back() 和 push_back() 的区别，就在于底层实现的机制不同。push_back() 向容器尾部添加元素时，首先会创建这个元素，然后再将这个元素拷贝或者移动到容器中；而 emplace_back() 在实现时，则是直接在容器尾部创建这个元素，省去了拷贝或移动元素的过程。为了让大家清楚的了解它们之间的区别，我们创建一个包含类对象的 vector 容器，如下所示：

#include  
#include  
using namespace std;
class testDemo
{
public:
    testDemo(int num):num(num){
        std::cout << "调用构造函数" << endl;
    }
    testDemo(const testDemo& other) :num(other.num) {
        std::cout << "调用拷贝构造函数" << endl;
    }
    testDemo(testDemo&& other) :num(other.num) {
        std::cout << "调用移动构造函数" << endl;
    }
private:
    int num;
};
int main()
{
    cout << "emplace_back:" << endl;
    std::vector<testDemo> demo1;
    demo1.emplace_back(2);  
    cout << "push_back:" << endl;
    std::vector<testDemo> demo2;
    demo2.push_back(2);
}

运行结果为：

emplace_back:
调用构造函数
push_back:
调用构造函数
调用移动构造函数

emplace()和insert()的区别

insert() 函数的功能是在 vector 容器的指定位置插入一个或多个元素。

下面的例子，演示了如何使用 insert() 函数向 vector 容器中插入元素。

#include  
#include  
#include  
using namespace std;
int main()
{
    std::vector<int> demo{1,2};
    //第一种格式用法
    demo.insert(demo.begin() + 1, 3);//{1,3,2}
    //第二种格式用法
    demo.insert(demo.end(), 2, 5);//{1,3,2,5,5}
    //第三种格式用法
    std::array<int,3>test{ 7,8,9 };
    demo.insert(demo.end(), test.begin(), test.end());//{1,3,2,5,5,7,8,9}
    //第四种格式用法
    demo.insert(demo.end(), { 10,11 });//{1,3,2,5,5,7,8,9,10,11}
    for (int i = 0; i < demo.size(); i++) {
        cout << demo[i] << " ";
    }
    return 0;
}

运行结果为：

1 3 2 5 5 7 8 9 10 11

emplace()是 C++ 11 标准新增加的成员函数，用于在 vector 容器指定位置之前插入一个新的元素。emplace() 每次只能插入一个元素，而不是多个。

该函数的语法格式如下：

iterator emplace (const_iterator pos, args...);

其中，pos 为指定插入位置的迭代器；args… 表示与新插入元素的构造函数相对应的多个参数；该函数会返回表示新插入元素位置的迭代器。

举个例子：

#include 
#include 
using namespace std;
int main()
{
    std::vector<int> demo1{1,2};
    //emplace() 每次只能插入一个 int 类型元素
    demo1.emplace(demo1.begin(), 3);
    for (int i = 0; i < demo1.size(); i++) {
        cout << demo1[i] << " ";
    }
    return 0;
}

运行结果为：

3 1 2

既然 emplace() 和 insert() 都能完成向 vector 容器中插入新元素，那么谁的运行效率更高呢？答案是 emplace()。在说明原因之前，通过下面这段程序，就可以直观看出两者运行效率的差异：

#include 
#include 
using namespace std;
class testDemo
{
public:
    testDemo(int num) :num(num) {
        std::cout << "调用构造函数" << endl;
    }
    testDemo(const testDemo& other) :num(other.num) {
        std::cout << "调用拷贝构造函数" << endl;
    }
    testDemo(testDemo&& other) :num(other.num) {
        std::cout << "调用移动构造函数" << endl;
    }
    testDemo& operator=(const testDemo& other);
private:
    int num;
};
testDemo& testDemo::operator=(const testDemo& other) {
    this->num = other.num;
    return *this;
}
int main()
{
    cout << "insert:" << endl;
    std::vector<testDemo> demo2{};
    demo2.insert(demo2.begin(), testDemo(1));
    cout << "emplace:" << endl;
    std::vector<testDemo> demo1{};
    demo1.emplace(demo1.begin(), 1);
    return 0;
}

运行结果为：

insert:
调用构造函数
调用移动构造函数
emplace:
调用构造函数

可以看到，通过 insert() 函数向 vector 容器中插入 testDemo 类对象，需要调用类的构造函数和移动构造函数（或拷贝构造函数）；而通过 emplace() 函数实现同样的功能，只需要调用构造函数即可。

简单的理解，就是 emplace() 在插入元素时，是在容器的指定位置直接构造元素，而不是先单独生成，再将其复制（或移动）到容器中。因此，在实际使用中，推荐大家优先使用 emplace()。

resize()和reserve()的区别

1. resize()调整容器中有效数据区域的尺寸，如果尺寸变小，原来数据多余的截掉。若尺寸变大，不够的数据用该函数第二个参数填充,影响size。
2. reserve()为容器预留足够的空间，分配空间大于等于函数的参数，影响capacity。