为什么复制构造函数被调用了 25 次，而插入循环只迭代了 10 次？

Question

我想知道为什么在下面的 C++ 代码中复制构造函数被调用 25 次 10 次迭代？

如果是 10 那么可以 10/10 = 1，或者 20/10 = 2，或者 30/10 = 3，但是 25/10 = 2.5？这里的.5是什么意思？

Header:

class Person
{
public:
    Person(std::string name, int age);
    Person(const Person &person);

    const std::string &getName() const;
    int getAge() const;

private:
    std::string name;
    int age;
};

来源：

Person::Person(string name, int age) : name(std::move(name)), age(age)
{}

Person::Person(const Person &person)
{
    this->name = person.name;
    this->age = person.age;
    static int count = 0;
    count++;
    cout << ">>Copy-Person::Person(Person &person) " << count << endl;
}

const string &Person::getName() const
{
    return name;
}

int Person::getAge() const
{
    return age;
}

用法：

int main()
{
    vector<Person> persons;

    for (int i = 0; i < 10; ++i)
    {
        Person person(to_string(i + 1), i);
        persons.push_back(person);
    }
    cout << "-----------------------------------------------" << endl;
    for (Person &person : persons)
    {
        cout << "name = " << person.getName() << " age = " << person.getAge() << endl;
    }
    return 0;
}

输出：

>>Copy-Person::Person(Person &person) 1
>>Copy-Person::Person(Person &person) 2
>>Copy-Person::Person(Person &person) 3
>>Copy-Person::Person(Person &person) 4
>>Copy-Person::Person(Person &person) 5
>>Copy-Person::Person(Person &person) 6
>>Copy-Person::Person(Person &person) 7
>>Copy-Person::Person(Person &person) 8
>>Copy-Person::Person(Person &person) 9
>>Copy-Person::Person(Person &person) 10
>>Copy-Person::Person(Person &person) 11
>>Copy-Person::Person(Person &person) 12
>>Copy-Person::Person(Person &person) 13
>>Copy-Person::Person(Person &person) 14
>>Copy-Person::Person(Person &person) 15
>>Copy-Person::Person(Person &person) 16
>>Copy-Person::Person(Person &person) 17
>>Copy-Person::Person(Person &person) 18
>>Copy-Person::Person(Person &person) 19
>>Copy-Person::Person(Person &person) 20
>>Copy-Person::Person(Person &person) 21
>>Copy-Person::Person(Person &person) 22
>>Copy-Person::Person(Person &person) 23
>>Copy-Person::Person(Person &person) 24
>>Copy-Person::Person(Person &person) 25
-----------------------------------------------
name = 1 age = 0
name = 2 age = 1
name = 3 age = 2
name = 4 age = 3
name = 5 age = 4
name = 6 age = 5
name = 7 age = 6
name = 8 age = 7
name = 9 age = 8
name = 10 age = 9

Answer 1

您没有为 persons 矢量保留任何内存。这意味着当 persons.size() == persons.capacity() 在 push_back 期间，向量将在堆上分配一个新的更大的缓冲区并将每个元素复制到它。这就是为什么您看到的副本比预期的多。

如果你写...

persons.reserve(10);

...在循环之前，您将看不到任何 "extra" 副本。

live example on wandbox

请注意，您可以通过同时使用 std::vector::emplace_back 和 std::vector::reserve 来完全避免复制：

for (int i = 0; i < 10; ++i)
{
    persons.emplace_back(to_string(i + 1), i);
}

这只会打印：

name = 1 age = 0

name = 2 age = 1

name = 3 age = 2

name = 4 age = 3

name = 5 age = 4

name = 6 age = 5

name = 7 age = 6

name = 8 age = 7

name = 9 age = 8

name = 10 age = 9

live example on wandbox

Answer 2

当 size() > capacity() 的 vector 时，重新分配发生。所有元素将被复制到新的内部存储中，然后复制构造函数将以当前元素的次数被调用。有关如何增加容量的详细信息取决于实施，您使用的实施似乎只是每次重新分配的容量增加一倍。所以

#iterator current size  capacity  times of the copy (for reallocatioin + for push_back)
1         0             0         0 + 1             
2         1             1         1 + 1             
3         2             2         2 + 1             
4         3             4         0 + 1             
5         4             4         4 + 1             
6         5             8         0 + 1             
7         6             8         0 + 1             
8         7             8         0 + 1             
9         8             8         8 + 1             
10        9             16        0 + 1

这就是为什么你得到了 25 次的结果。

正如@VittorioRomeo 所解释的，您可以使用 std::vector::reserve 来避免重新分配。

Answer 3

当std::vector::size()达到std::vector::capacity()时，std::vector将为更多的对象腾出空间，分配一个新的更大容量的缓冲区，并且将之前存储的对象复制到新缓冲区中。
这会为您的 Person class 触发新的复制构造函数调用（我用 VS2015 尝试了您的代码，我得到了 35 个复制构造函数调用）。

请注意，如果您使用 reserve() 方法在 std::vector 中预留足够的空间，您将得到恰好 10 次复制构造函数调用：

vector<Person> persons;

// Reserve room in the vector to store 10 persons
persons.reserve(10);

for (int i = 0; i < 10; ++i)
{
    Person person(to_string(i + 1), i);
    persons.push_back(person);
}

这是因为，在这种情况下，您在向量中留出了足够的空间，因此向量的大小不会超过其容量（因此，无需分配新的更大的缓冲区，并将旧数据复制到此新缓冲区）。

综上所述，如果您的 Person class 是 可移动构造的 ，std::vector 将移动以前创建的 Person 对象而不是复制它们，这样更快。

如果您在 Person class:

中添加此行

class Person 
{
  public:
   ...

   // Synthesize default move constructor
   Person(Person&&) = default;
   ...
};

即使您不调用 vector::reserve() 方法，您也将得到恰好 10 次复制构造函数调用。

为什么复制构造函数被调用了 25 次，而插入循环只迭代了 10 次？

Why the copy constructor is called 25 times, while the insertion loop iterates only 10 times?

c++

vector

copy-constructor