What does "when the member is then reinitialized re initialized otherwise in the constructor" mean in cplusplus.com tutorial?

Question

I'm reading classes tutorial in cplusplus.com.

I got confused by the following paragraph.

Default-constructing all members of a class may or may always not be convenient: in some cases, this is a waste (when the member is then reinitialized otherwise in the constructor), but in some other cases, default-construction is not even possible (when the class does not have a default constructor). In these cases, members shall be initialized in the member initialization list.

So, my question is what does the "when the member is then reinitialized otherwise in the constructor" mean? Why is a waste?

In the beginning, I think the "reinitialized` like following code.

class Son
{
    int age;

public:
    // default constructor
    Son()
    {
        age = 1;
    }

    Son(int age) : age(age) {}
};

class Father
{
    Son son;    // First, I think that it will call default constructor of class Son when the object of Father was created
    int age;

public:
    // Then object of Father will call this constructor, then initialize son again.
    Father(int sonAge, int fatherAge) : son(sonAge), age(fatherAge)
    {
    }

};

Then, I found Son son wasn't to define son at all, it just waited the constructor of Father to initialized son. So this isn't waste, my idea is wrong!!! Maybe I lack the knowledge of object creation order? cplusplus.com provides tutorial seems incomplete for me...

Can you give me a few code examples?

Answer 1

All objects are initialized before the body of the constructor is entered, so let's walk this through step-by-step:

int age;
Son() // age initialized here (does nothing)
{
    age = 1;// age assigned new value here
}

But what if age is something more complicated than an int? What if it is a class with very expensive construction?

Expensive age;
Son() // age initialized here takes a lot of time and resources
{
    age = 1;// age assigned new value here. This requires construction of a 
            // temporary Expensive (which takes a lot of time and resources)
            // and then assigns the temporary to age (which may also be time and 
            // resource-consuming), wasting the effort spent on the default 
            // construction. The temporary is then destroyed, and that wastes 
            // even more
}

If you use the Member Initializer List

Expensive age;
Son(): age(1) // age initialized here takes a lot of time and resources
{
    // does nothing
}

Note: The above is a worst-case example. Expensive could have an Expensive &operator=(int) that shaves off some of the work, but you still need to deal with default construction and the assignment logic in place of a single constructor call. Plus someone had to write the = overload, and code that doesn't exist has no bugs.

Answer 2

So, my question is what does the "when the member is then reinitialized otherwise in the constructor" mean?

There is no such thing as "reinitialization". Every object is initialized exactly once (although that initialization may be vacuous, meaning it doesn't actually do anything; also there is zero-initialization before actual initialization in certain cases, which may be considered two initializations). What the author intents this to mean is assignment after the initialization.

In your example this happens with the constructor

Son()
{
    age = 1;
}

This constructor has no member initializer, meaning that the member age (which doesn't have a default initializer in its declaration either) will be default-initialized. Only after the initialization is the body of the constructor executed and the assignment age = 1; done.

Now in this case there is basically no waste because default-initialization of an int does not do anything (it leaves the value indeterminate). However imagine age was a std::string and the assignment was age = "1"; instead. Then you would first call the default constructor of std::string to initialize age and then later you would assign "1" to age. The first step is redundant and using an initializer list Son() : age("1") { } would avoid that extra step. (Whether or not there will actually be any performance difference depends on many factors and the compiler may just be good enough to optimize both to the same machine code.)

One issue with the word "intialization" is that it is colloquially often used differently from the technical meaning described above. Colloquially it may refer to the first time a variable has its value set. In this case the assignment age = 1; would be considered to initialize age, although that is assignment, not initialization. This meaning is most often used when talking about a variable being uninitialized, which more technically correct should be being of indeterminate value.