C + + initialization list Learning _c language

What is a list of initialization
Unlike other functions, constructors can have initialization lists, in addition to names, argument lists, and function bodies, which begin with a colon, followed by a series of comma-delimited initialization fields. In C + +, the only difference between struct and class is that the default gram access is different, and here we don't consider the problem of accessibility, so the following code is demonstrated with struct.

Copy Code code as follows:

struct FOO
{
String name;
int id;
Foo (string s, int i): name (s), id (i) {}; Initializing a list
};

two execution stages of a constructor
The execution of a constructor can be divided into two phases, initialization phase and calculation phase, initialization phase prior to the calculation stage.

Initialization phase
The members of all class types (classes type) are initialized during the initialization phase, even if the member does not appear in the constructor's initialization list.

Calculation phase
Typically used to perform assignment operations within the body of a constructor, the following code defines two structures, where Test1 has constructors, copy constructors, and assignment operators to facilitate viewing of the results. Test2 is a test class that takes a Test1 object as a member, and we look at how the Test2 constructor executes.

Copy Code code as follows:

struct TEST1
{
Test1 ()//parameterless constructor
{
cout << "construct Test1" << Endl;
}

Test1 (const test1& T1)//copy constructor
{
cout << "Copy constructor for Test1" << Endl;
This->a = t1.a;
}

test1& operator = (const test1& t1)//assignment operator
{
cout << "Assignment for Test1" << Endl;
This->a = t1.a;
return *this;
}

int A;
};

struct TEST2
{
Test1 test1;
Test2 (Test1 &t1)
{
Test1 = T1;
}
};

Calling code

Copy Code code as follows:

Test1 T1;
Test2 T2 (T1);

Output

Explain that the first line of output corresponds to the first line in the calling code and constructs a Test1 object. The second line of output corresponds to the code in the Test2 constructor and initializes the object test1 with the default constructor, which is the so-called initialization phase. The third line outputs the assignment operator corresponding to the TEST1, performing assignment operations on Test1, which is called the computational phase.

Why use the initialization list
There are two ways to initialize members of a class, one is to use an initialization list, and the other is to perform assignment operations in the constructor body. Using an initialization list is primarily based on performance issues, and for built-in types such as int, float, and so on, initializing the class table and initializing the difference in the constructor body is not very significant, but for class types it is best to use an initialization list. From the test above, it is very efficient to use the initialization list to call the default constructor one less time for data-intensive classes. Also look at the example above, we use the initialization list to implement the Test2 constructor

Copy Code code as follows:

struct TEST2
{
Test1 test1;
Test2 (Test1 &t1): test1 (t1) {}
}

Using the same calling code, the output is as follows.

The first line of output corresponds to the first line of the calling code. The second line outputs the initialization list corresponding to the TEST2, directly calling the copy constructor to initialize the Test1, eliminating the process of invoking the default constructor. So a good rule is to use the initialization list whenever possible using the initialization list.

Which things must be placed in the initialization list
In addition to performance issues, there are times when initialization lists are essential, and you must use an initialization list in the following situations

Constant member, because a constant can only initialize a value that cannot be assigned, so it must be placed in the initialization list
Reference type, the reference must be initialized at the time of definition, and cannot be assignable, so write it in the initialization list
A class type that does not have a default constructor, because using an initialization list can be initialized without invoking the default constructor, but directly by calling the copy constructor.
For classes that do not have a default constructor, let's look at an example.

Copy Code code as follows:

struct TEST1
{
Test1 (int a): I (a) {}
int i;
};

struct TEST2
{
Test1 test1;
Test2 (Test1 &t1)
{
Test1 = T1;
}
};

The above code cannot be compiled because the test1 = T1 in the Test2 constructor is actually divided into two steps.

1. Invoke the default constructor of the Test1 to initialize the Test1
2. Call the Test1 assignment operator to assign the Test1 value

However, because Test1 does not have a default constructor, the so-called first step cannot be executed, so compile error. The correct code is as follows, using an initialization list instead of an assignment operation.

Copy Code code as follows:

struct TEST2
{
Test1 test1;
Test2 (Test1 &t1): test1 (t1) {}
}

initialization order for member variables
Members are initialized according to the order in which they appear in the class, rather than in the order in which they appear in the initialization list, looking at the code.

Copy Code code as follows:

struct FOO
{
int i;
Int J;
Foo (int x): I (x), J (i) {}; OK, first initialize I, then initialize J
};

And look at the code below.

Copy Code code as follows:

struct FOO
{
int i;
Int J;
Foo (int x): j (x), I (j) {}//I value undefined
};

The value of I here is undefined because although J appears in the initialization list in front of I, but I is preceded by J, I is initialized first, but I is initialized by J, at this time J has not been initialized, so the value of I is undefined. So, a good habit is to initialize in the order of the members defined.