How usage of member initializer list prevents creation of redundant object in c++?

Question

I have a question regarding difference in initializing an object with and without constructor member initializer list.

In the following code snippet there are two classes Test1 and Test2 each with two constructors, objects of these two classes are created in the default constructor of another class Example. Object of Test1 is created with one parameter in member initializer list, whereas that of Test2 is created with one parameter inside constructor body of Example.

class Test1 {
public:
    Test1()      { cout << "Test1 is created with no argument"; }
    Test1(int a) { cout << "Test1 is created with 1 argument"; }
};

class Test2 {
public:
    Test2()      { cout << "Test2 is created with no argument"; }
    Test2(int a) { cout << "Test2 is created with 1 argument"; }
};

class Example {
public:
    Test1 objTest1;
    Test2 objTest2;

    Example() : objTest1(Test1(50)) 
    {
            objTest2 = Test2(50);
    }
};

int main() 
{
    Example e;
}

The output of the above code is :

Test1 is created with 1 argument

Test2 is created with no argument

Test2 is created with 1 argument

My Questions

Why does object of Test2 is created twice? (The one which is created without member initializer.)
What had happened to the redundant object of Test2? Does it still occupies some memory?
How does member initializer list works in initializing class member variables?
Is there is any performance benefit in using member initializer list? (As Test1 is created only once)

`Test2` is first create without argument (default constructor), and then a second time when you call it's constructor inside the `Example` constructor body. What's unclear about that behavior? — πάντα ῥεῖ, Dec 25 '18 at 13:09
When you create Example e it creates objTest2 and then you overwrite it with a new object, while you specify how to initialize objTest2 in the constructor. — Ian4264, Dec 25 '18 at 13:12

score 3 · Accepted Answer · answered Dec 25 '18 at 13:12

Your Example constructor is (implicitly) equivalent to

Example() : objTest1(Test1(50)), objTest2()
{
        objTest2 = Test2(50);
}

That is, the objTest2 object is constructed and initialized once implicitly (this is inserted by the compiler).

Then you inside the body explicitly construct and initialize a temporary Test2 object that is used to assign to objTest2.

Also note that in the initializer list objTest1(Test1(50)) constructs a temporary Test1 object, and passes it to the copy-constructor for the initialization of objTest1 (though most compilers should elide this copying). You can simplify it as plain objTest1(50).

How usage of member initializer list prevents creation of redundant object in c++?

1 Answers1