C++ vector pushback method and temporary object creation

Question

Below is the signature of vector pushback method in C++.

 void push_back (const value_type& val);

Now below is code

class MyInt
{
   int *a;
public:
  MyInt(int n):a(new int(n)){cout<<"constructor called"<<endl;}
   ~MyInt(){cout<<"destructor called"<<endl;}
   void show(){
   cout<<*a<<endl;
   }
 };


 void vector_test(vector<MyInt> &v)
 {
    MyInt m1(1);
    MyInt m2(2);
    v.push_back(m1);   
    v.push_back(m2);
 }



Output
-------------
constructor called
constructor called
destructor called
destructor called
destructor called
1
2
destructor called
destructor called

Here we see that for 2 objects which is created in vector_test function causes 2 times constructor invocation. But for destructor it got invoked 5 times.

Now my doubts and questions are

1. How come number of constructor and destructor calls are not matching?
2. I understand that there are some temporary objects getting created. But how this mechanism is working?
3. Just to test, I tried to provide a copy constructor but it causes compilation failure. What could be the reason?
4. Is there some logic inside which is copying the contents of m1 and m2 into new objects and puts in to the container?

I would really appreciate if someone explain this in detail. Thanks..

Answer 1

You need to add logging also for copy constructor:

MyInt(const MyInt& rhs):a(new int(*rhs.a)){cout<<"copy constructor called"<<endl;}

Some constructor calls are allowed by compiler to be elided, ie. in following line:

MyInt m1 = 1;

you might expect copy constructor to be first called to instantiate temporary MyInt(1) then a copy constructor called with this temporary. So you would see:

constructor called // for temporary
copy constructor called // for m1
destructor called       // for m1
destructor called  // for temporary

but because of copy elision compiler will directly instantiate your m1 instance using MyInt(int n) constructor, even though your copy constructor has side effects (std::cout is used). So no above // for temporary logs will be present.

To see this with gcc use: -fno-elide-constructors option which diasbles copy constructor elision.

Also it is a good practice to make constructors such as MyInt(int n) explicit, this is to disallow making MyInt object instance by mistake - you will have to make it explicit, i.e. MyInt var; var = static_cast<MyInt>(1);.

Answer 2

You have to remember that the compiler can potentially add five methods if you don't provide them. Im this case you are being affected by the compiler generated copy constructor.

#include <iostream>
#include <vector>
using namespace std;

class MyInt
{
   int *a;
public:
  MyInt(int n):a(new int(n)){cout<<"constructor called"<<endl;}
  MyInt(MyInt const& copy): a(new int(*copy.a)) {cout<<"copy constructor called"<<endl;}
  MyInt(MyInt&& move): a(move.a) {move.a = nullptr; cout<<"move constructor called"<<endl;}
   ~MyInt(){cout<<"destructor called"<<endl;}
   void show(){
   cout<<*a<<endl;
   }
 };


 void vector_test(vector<MyInt> &v)
 {
    MyInt m1(1);
    MyInt m2(2);
    v.push_back(m1);
    v.push_back(m2);
 }

 int main()
 {
    vector<MyInt> v;
    vector_test(v);
 }

When I run this I get

batman> ./a.out
constructor called
constructor called
copy constructor called
copy constructor called
copy constructor called
destructor called
destructor called
destructor called
destructor called
destructor called

Note: You are leaking memory from the destructor.

This is also why we have the emplace_back() interface. This will reduce the number of copies of the object that are created. Additionally when optimizations are enabled you will see that some of those object are not copied but created in-place.

 void vector_test(vector<MyInt> &v)
 {
    MyInt m1(1);
    MyInt m2(2);

    // Can use emplace back
    v.emplace_back(1); // Created the object in-place in the vector.

    // Or you can use a temorary.
    v.push_back(2);  // Compiler sees there is a single argument constructor
                     // and will insert the constructor to convert a 2 into
                     // MyInt object.

    v.push_back(MyInt(3)); // Or you can create a temporary explicitly.
 }