什么是capacity和size?

capacity表示的容器内可以容纳多少个对象，表示的是能力，是可以，不代表容器内就有这么多个对象。
size表示的实实在在的有多少个对象。

capacity和size动态增加

随着emplace_back或者push_back,vector的capacity和size都会增加。
capacity的增加基本上是翻倍的，比如0,1,2,4,8,16。

#include 
#include 

using namespace std;

struct Student
{
    string name;
    int age;

    Student() { cout << "默认构造" << endl; }
    Student(string &n, int a)
        : name(n), age(a)
    {
        cout << "构造" << endl;
    }

    Student(string &&n, int a)
        : name(move(n)), age(a)
    {
        cout << "构造" << endl;
    }

    Student(const Student &s)
        : name(s.name), age(s.age)
    {
        cout << "拷贝构造" << endl;
        ;
    }

    Student(Student &&s)
        : name(std::move(s.name)), age(s.age)
    {
        cout << "移动构造" << endl;
    }

    ~Student() { cout << "析构" << endl; }
};

void print_status(const vector<Student> &students)
{
    cout << "capacity " << students.capacity() << endl;
    cout << "actual size " << students.size() << endl;
    cout << "----------------" << endl;
}

int main()
{
    vector<Student> students;

    print_status(students);

    // students.resize(5);//调用默认构造
    // students.reserve(5);//只是分配内存，增加capacity
    students.emplace_back("xiaohong", 24);
    print_status(students);

    students.emplace_back("xiaohong", 24);
    print_status(students);


    students.emplace_back("xiaohong", 24);
    print_status(students);


    students.emplace_back("xiaohong", 24);
    print_status(students);


    students.emplace_back("xiaohong", 24);
    print_status(students);


    students.emplace_back("xiaohong", 24);
    print_status(students);

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

输出

capacity 0
actual size 0
----------------
构造
capacity 1
actual size 1
----------------
构造
拷贝构造
析构
capacity 2
actual size 2
----------------
构造
拷贝构造
拷贝构造
析构
析构
capacity 4
actual size 3
----------------
构造
capacity 4
actual size 4
----------------
构造
拷贝构造
拷贝构造
拷贝构造
拷贝构造
析构
析构
析构
析构
capacity 8
actual size 5
----------------
构造
capacity 8
actual size 6
----------------
析构
析构
析构
析构
析构
析构
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

capacity翻倍导致容器内对象的复制构造

如上代码所示，capacity翻倍的时候，会导致已经存在的对象重新复制构造。这种操作比耗费资源。

resize()-实实在在的默认构造

resize(count),count小于当前实际的size,则会析构掉多余的对象。
resize(count),count大于当前实际的size,小于等于capacity,则会调用默认构造。
resize(count),count大于capacity,则会调用默认构造和复制构造（构造之前就存在的对象）。

reserve()-只分配足够的内存，不构造

reserve(count),count大于当前的capacity，则会调用复制构造，构造之前就存在的对象。
reserve(count),count小于capacity，则不会有任何影响。

提升效率的方法

为了减少不必要的复制构造，最好能够在添加对象前，合理的使用reserve,预分配好合适的资源。