c++初始化列表_c++继承初始化列表

c++类对象的构造顺序:

1. 分配内存，调用构造函数时，隐式／显示的初始化各数据成员。
2. 进入构造函数后在构造函数中执行一般计算。

class Person
{
private:
    int age;

public:
    Person(int age)
    {
        this->age = age;
    }

    int getAge() 
    {
        return age;
    }
};

int main()
{
   Person* p = new Person(10);
   std::cout << p->getAge() << std::endl;

   return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

以上代码中 this->age = age; 执行前age已经被默认初始化。

初始化列表的优势

提高效率，省掉构造函数中的开销。

初始化顺序：

它是关于C++初始化类成员的，它们是按照声明的顺序初始化的，而不是按照出现在初始化列表中的顺序。

#include <iostream>

class Test
{
private:
    int x;
    int y;

public:
    Test(int a, int b): y(b), x(y) 
    {
    }

    int getX() 
    {
        return x;
    }

    int getY()
    {
        return y;
    }
};

int main()
{
   Test* test = new Test(1,2);
   std::cout << test->getX() << std::endl;
   std::cout << test->getY() << std::endl;

   return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

运行结果：

0
2
1
2

可能以为上面的代码将会首先初始化 y = 2，然后再初始化 x = y = 2，然而x = 0,因为按照声明的顺序是要先初始化x, 然后再初始化y,所以x = 0。

使用场景：

• 常量成员，因为常量只能初始化不能赋值，所以必须放在初始化列表里面。
• 引用类型，引用必须在定义的时候初始化，并且不能重新赋值，所以也要写在初始化列表里面。
• 没有默认构造函数的类类型，因为使用初始化列表可以不必调用默认构造函数来初始化，而是直接调用拷贝构造函数初始化。

class ABC
{
public:
         ABC(int x,int y,int z);
private:
         int a;
         int b;
         int c;
};
class MyClass
{
public:
        MyClass():abc(1,2,3)
        {
        }
private:
        ABC abc;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• C++在继承里面，当父类构造函数为有参构造时，需要使用初始化列表。

class Base
{
private:
    int i;
public:
    Base(int i){
        this->i = i;
    }
};

class Inheritance: public Base
{
private:
    int j;
public:
    Inheritance(int j): Base(10)
    {
        this->j = j;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20