Use of constructor in C++

This is very trivial question regarding the use of a constructor in C++. I will present in the form of an interview dialogue (it was difficult to present it in any other forms)

interviewer - what is a constructor?

me - constructor are special functions which makes sure that all objects are initialized before their use.

interviewer - what is an initializer list?

me - that is a list where all the initialization happens. A constructor's body is entered only after all the data members are initialized, or some constructor of all the member objects are called.

interviewer - that means initialization is carried out in initializer list, not inside constructor. But you said constructor initialize the object! Didn't you? Do you want to answer my first question.

me - I think constructor does assignment, it calls assignment operator on already initialized member objects.

So my question to you can be

how initializer list works?

what lies between function's starting address & starting braces [{]?

开发者_如何转开发or just answer me how to convince my interviewer.

Technically speaking, your interpretation is accurate. No members may be initialised from inside the ctor body; only in the ctor-initializer. Any member access in the ctor body may only be assignment.

All members are "initialised" before the ctor body is entered.

However, speaking more broadly, since the body always follows the initializer, it's said that — as a unit — the object is initialised once the constructor has ended... including the body.

Partly this is because, again speaking broadly, you might consider initialisation to include some business logic that you must perform in your ctor body, even though this is not the same as actual initialisation of a data member.

You're overthinking it and allowing the interviewer to confuse you.

Initializing the members of an object is not the same thing as initializing the object itself. Just because the members have sane values doesn't mean the object has been constructed. Until the constructor has completed, the object itself has not been properly initialized.

The main things about an initialisation list are efficiency and code readability.

The readability part is self-explanatory, because you know exactly where to look to see where the values are initialised. The efficiency saving comes in the fact that if you assign them values within the code of the constructor instead, then they will be assigned twice: firstly when the object is created they will be assigned the values provided by that datatype's default constructor, then they will be assigned a new value within your object's constructor. The initialisation list just insures that they are initialised with the value you specified to begin with.

for example, here is an example of an initialisation list I used in a Doubly Linked List implementation:

template <typename T>
LinkedList<T>::LinkedList()
: size(0)
, pHead(NULL)
, pTail(NULL)
{
}

Whereas the less efficient version where size, pHead and pTail get assigned twice is shown below:

template <typename T>
LinkedList<T>::LinkedList()
{
    size = 0;
    pHead = NULL;
    pTail = NULL;
}

Essentially, you are correct but the member initializer shouldn't be considered separate from the constructor. The initializer is a part of the constructor and is called before the main body of the constructor.

When you declare an automatic variable of a built-in type, it is both a definition and a declaration. It's a declaration because an identifier is bound to a type and it's a definition because the compiler allocates storage for it.

int var1; // declares/defines var of type int

int var2 = 0; // declares/defines a var of type int and initializes it to 0

An initializer sets the variable with an initial value when it is defined but it's considered defined before the initializer.

int x = 5;
int y = 5;

int main()
{
    int x = x; // x is undefined here not 5 because x refers to itself
    int y[y];
    int size = sizeof(y)/sizeof(int); // size is 5 (y[5]) since y isn't defined until after the enclosing bracket so y referred to the global y in the declaration.
}

There are some variables that must be initialized however. Constants and references.

It is the same with constructors. The point at which the members have been defined is right before the ctor body. This is the order that members and bases are defined when the constructor is called.

1. virtual base classes
2. base class
3. members--in the order in which they were declared
4. ctor body is executed

After leaving the constructor body, everything has been initialized.

If you don't use the initializer, then you can assume that its already defined when entering the ctor body but you can't assume it has any particular value. Again, constants and references must be initialized in the member initializer.

The initializer list is part of the constructor. Each constructor has its own.