How to explain that there are 9 times of destruction? - c++

Question

I want to learn what differences are between push_back() and emplace_back(), especially when the elements are class type.So I write code like following:
int cnt = 0;
class foo{
public:
//constructor
foo() : ucnt(++cnt) { cout << ucnt << "\tdefault" << endl; }
foo(const foo&) : ucnt(++cnt) { cout << ucnt << "\tcopy" << endl; }
~foo() { cout << ucnt << "\tdestroyed" << endl; }
int ucnt;
};
int main()
{
vector<foo> vf = {foo()};
cout << vf.size() << " : " << vf[0].ucnt << endl;
vf.push_back(foo());
cout << vf.size() << " : " << vf[0].ucnt << " " << vf[1].ucnt << endl;
vf.emplace_back(foo());
cout << vf.size() << " : " << vf[0].ucnt << " " << vf[1].ucnt << " " << vf[2].ucnt << endl;
return 0;
}
whose result is:
1 default
2 copy
1 destroyed
1 : 2
3 default
4 copy
5 copy
2 destroyed
3 destroyed
2 : 5 4
6 default
7 copy
8 copy
9 copy
5 destroyed
4 destroyed
6 destroyed
3 : 8 9 7
8 destroyed
9 destroyed
7 destroyed
It seems like all the elements in vf are copyed and then destroyed while executing push_back() and emplace_back().Why?

Answer 1

emplace_back
The advantage of emplace_back is that it passes its arguments directly to the constructor of the to-be-emplaced class and constructs the new object in place instead of copy constructing it.
e.g.
elections.emplace_back("Nelson Mandela", "South Africa", 1994);
As opposed to push_back, where you pass a temporary object and copy construct the new object.
e.g.
elections.push_back(President("Franklin Delano Roosevelt", "the USA", 1936));
so in your case it should be
vf.emplace_back();
since you have no ctor arguments to be passed to the in place constructor. Compared to
vf.push_back(foo());
Constructor balance
The many unexpected copies and deletes stem from resizing the vector.
up to 1. cout
1 temporary created, and destroyed in constructor
= 1x default, 1x copy, 1x destroyed ✔️
up to 2. cout
1 temporary created and destroyed in push_back
1 existing object copied to the resized vector, therefor copy-created and destroyed
= 1x default, 2x copy, 2x destroyed ✔️
up to 3. cout
1 temporary created and destroyed in emplace_back
2 existing objects copied to the resized vector, therefor copy-created and destroyed
= 1x default, 3x copy, 3x destroyed ✔️
and so on
Edit: Example
The following code is from Artemy Vysotsky, see comment under this answer and shows exactly to the point how it is done right. Especially note the use of .reserve(3) to avoid reallocation orgies.
#include <vector>
#include <iostream>
using std::cout;
int cnt = 0;
class foo{
public:
//constructor
foo() : ucnt(++cnt) { cout << ucnt << "\tdefault\n" ; }
foo(const foo&) : ucnt(++cnt) { cout << ucnt << "\tcopy\n" ; }
foo(foo&&) noexcept : ucnt(++cnt) { cout << ucnt << "\tmove\n" ; }
~foo() { cout << ucnt << "\tdestroyed\n" ; }
int ucnt;
};
int main()
{
std::vector<foo> vf = {foo()};
cout << vf.size() << " 1: " << vf[0].ucnt << '\n';
vf.reserve(3);
cout << vf.size() << " 2: " << vf[0].ucnt << '\n';
vf.push_back(foo());
cout << vf.size() << " 3: " << vf[0].ucnt << " " << vf[1].ucnt << '\n';
vf.emplace_back();
cout << vf.size() << " 4: " << vf[0].ucnt << " " << vf[1].ucnt << " " << vf[2].ucnt << '\n';
return 0;
}
/***************
Output
$ ./test
1 default
2 copy
1 destroyed
1 1: 2
3 move
2 destroyed
1 2: 3
4 default
5 move
4 destroyed
2 3: 3 5
6 default
3 4: 3 5 6
3 destroyed
5 destroyed
6 destroyed
*****************/