Constructor initializer list is not calling copy constructor

Question

So I was learning about constructor initializer list and I wrote the following code :

class Mango
{
  public:

  Mango(){cout<<"Mango::ctor()";}
  Mango(const Mango& other){cout<<"Mango::copy_ctor()";}
};

class Box
{
    public:

    Box() : mango(Mango()) //**doesn't call copy constructor**
    {
    }

    Mango mango;
};

int main()
{
  Box box; 

   return 0;
}

I used g++ compiler for this. Its calling the constructor not copy constructor. It should call copy constructor right because I am creating an object to create another object? What's the issue here and what does standard says about it?

The default constructor is called because you do `Mango()`. What then happens is [*copy-elision*](https://en.wikipedia.org/wiki/Copy_elision). — Some programmer dude, Jun 20 '18 at 06:37

score 18 · Answer 1 · edited Jun 20 '20 at 09:12

Because of copy elision, the copy-construction is omitted here. This behavior is guaranteed from C++17. Before C++17 it's not mandatory; the compilers are permitted, but not required to perform copy elision¹.

Under the following circumstances, the compilers are required to omit the copy- and move- construction of class objects even if the copy/move constructor and the destructor have observable side-effects. They need not be present or accessible, as the language rules ensure that no copy/move operation takes place, even conceptually:
In initialization, if the initializer expression is a prvalue and the cv-unqualified version of the source type is the same class as the class of the destination, the initializer expression is used to initialize the destination object:
  T x = T(T(T())); // only one call to default constructor of T, to initialize x

That means, mango will initialized by the default constructor directly.

^[1] In fact most implementations would also perform copy elision before C++17. With Gcc you can try with -fno-elide-constructors option in pre-C++17 mode to disable copy elision.

score 2 · Answer 2 · answered Jun 20 '18 at 08:01

As songyuanyao already explained so well in his excellent answer, the compiler is permitted to optimize away the invocation of the copy constructor in a number of cases.

Still, I'd like to address a different part of your question, just in case there is some misunderstanding:

I used g++ compiler for this. Its calling the constructor not copy constructor. It should call copy constructor right because I am creating an object to create another object? What's the issue here and what does standard says about it?

Your copy constructor needs to be provided with a (const Mango& other) in order to be invoked. If the compiler were to not perform copy elision, you would first see a call to the "normal" constructor "Mango::ctor()" followed by a call to the copy-constructor "Mango::copy_ctor()". Copy elision merely optimizes away the unnecessary copy-constructor call - the constructor for the object needs to be called in either way in order to get the Mango() object in Box() : mango(Mango())

Constructor initializer list is not calling copy constructor

2 Answers2