c++类对象的初始化顺序

发表于 分类于 阅读次数： 本文字数： 1.2k 阅读时长 ≈ 1 分钟

  1. 按照继承声明顺序，初始化基类对象

  2. 初始化x的成员对象

  3. 调用x的构造函数

    对于例，写出一个对象的构造和析构过程

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
33
34
35
36
37
38
#include <iostream>
using namespace std;

class A
{
public:
    A() { cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }

};

class B
{
public:
    B() { cout << "B()" << endl; }
    ~B() { cout << "~B()" << endl; }
private:
    A a;
};

class Test : public A, public B // 派生列表
{
public:
    Test() { cout << "Test()" << endl; }
    ~Test() { cout << "~Test()" << endl; }


private:
    B ex1;
    A ex2;
};

int main()
{
    Test ex;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
构造
1. 根据继承声明顺序，初始化基类对象
   1.1 初始化A类对象   
       1.1.1 初始化A类成员对象，因为没有成员对象，就没有这步
       1.1.2 调用A类成员函数,构造A    A();
   1.2 初始化B类对象   
       1.2.1 初始化B类成员对象 
         1.2.1.1 包含A类对象，初始化A，A中没有成员对象，就直接调用构造 A()
       1.2.2 调用B类构造函数 B();

2.初始化当前派生类的成员对象
  2.1 包含B类成员，初始化B类成员对象,包含A类成员对象  A() 
      2.1.1 构造B类                             B()
  2.2 包含A类成员，初始化A类成员对象，调用A类构造函数 A()
3.调用当前派生类的构造函数   Test()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
析构，析构的顺序和构造的顺序是反着的，所以可以直接得出
~Test();
~A();
~B();
~A();
~B();
~A();
~A();
1.析构当前派生类对象  ~Test();
2.析构 当前派生类的成员对象，按照声明顺序逆序
   2.1 析构A
      ~A();
   2.2 析构B B中包含A类成员变量
      ~B();
      ~A();
3.按照继承列表逆序，析构继承类的对象
  3.1 B中包含成员变量A
      3.1.1 ~B();
      3.1.2 ~A();
  3.2 ~A();