C++成员初始化列表

ゝ一世哀愁。 2022-04-04 09:54 330阅读 0赞

### C++类成员初始化列表 ###

*  C++类型定义
 *  C++构造函数的初始化列表定义
 *  C++构造函数执行的两个阶段：初始化阶段和计算阶段
 *  为什么使用初始化列表
 *  C++里面哪些东西必须放在初始化列表里面
 *  成员变量的初始化顺序
 *  总结：C++构造函数逻辑执行顺序

> 这边文章主要学习C++里面的成员初始化列表。然后分析为什么需要成员初始化列表，C++构造器调用机制与Java区别。

# C++类型定义 #

在C++里面定义一个类型（比如有默认构造器的Test类）的方式一般是：

Test t1;

下面这个方式定义一个类变量会报错：

Test t1();

为什么呢？因为C++为了兼容C语言，对于上面的定义在C语言里面会被认为是一个函数声明。

所以我们定义一个类变量，然后调用默认构造函数，直接使用类似于`Test t1` 这种方式就行。

这里与Java有区别，在Java里面对于`Test t1` 代码只是做声明，并不会调用构造器做初始化。但是在C++里面会调用构造函数。

# C++构造函数的初始化列表定义 #

C++的构造函数与其他函数不同，构造函数除了有名字，参数列表和函数体之外，还可以有初始化列表，初始化列表以冒号开头，后跟一系列以逗号分隔的初始化字段。

比如下面的例子：

class Foo
    { 
    private:
        string name ;
        int id ;
    public:
        Foo(string s, int i):name(s), id(i){ } ; // 初始化列表
    };

# C++构造函数执行的两个阶段：初始化阶段和计算阶段 #

构造函数的执行可以分成两个阶段，**初始化阶段和计算阶段**，初始化阶段先于计算阶段执行。

初始化阶段

在定义的类中的所有的类类型（class type）的成员都会在初始化阶段初始化，也就是调用默认的无参数构造函数，即使该成员没有出现在构造函数的初始化列表中。

所以初始化阶段分为两个步骤：  
1）调用初始化列表  
2）未初始化的类成员(不在初始化列表)调用默认构造函数

比如对于下面的代码:

class BaseTest1{ 
    public:
        BaseTest1();
        BaseTest1(const BaseTest1& t1);
        BaseTest1& operator=(const BaseTest1& t1);
    private:
        int a;
    };
    
    BaseTest1::BaseTest1()
    { 
        cout << "BaseTest1 Constructor" << endl;
        this->a = 0;
    }
    
    BaseTest1::BaseTest1(const BaseTest1 &t1)
    { 
        cout << "BaseTest1 Copy Constructor" << endl;
        this->a = t1.a;
    }
    
    BaseTest1& BaseTest1::operator=(const BaseTest1 &t1)
    { 
        cout << "BaseTest1 assignment" << endl;
        this->a = t1.a;
        return *this;
    }
    
    class BaseTest2
    { 
    public:
        BaseTest2()
        { 
            cout << "BaseTest2 Constructor" << endl;
            this->a = 0;
        }
        BaseTest2(const BaseTest2& t)
        { 
            cout << "BaseTest2 Copy Constructor" << endl;
            this->a = t.a;
        }
        BaseTest2& operator=(const BaseTest2& t)
        { 
            cout << "BaseTest2 assignment" << endl;
            this->a = t.a;
            return *this;
        }
    private:
        int a;
    };
    
    
    class Test{ 
    public:
        Test(BaseTest1& t1, BaseTest2& t2):test1(t1)
        { 
            this->test2 = t2;
        }
    
    public:
        BaseTest2 test2;
        BaseTest1 test1;
    };
    
    
    int main(int argc, char* args[])
    { 
        BaseTest1 test1;
        BaseTest2 test2;
        Test test(test1, test2);
    }

执行结果是：

//执行main函数的第一和第二行，调用BaseTest1和BaseTest2的构造函数；
    BaseTest1 Constructor
    BaseTest2 Constructor
    // 因为Test类中test2变量不在初始化列表中，所以会先初始化Test类成员test2，然后调用初始化列表，也就是通过BaseTest1 Copy Constructor， 最后执行在Test的构造函数的逻辑，也就是test2的赋操作
    BaseTest2 Constructor
    BaseTest1 Copy Constructor
    BaseTest2 assignment

但是如果我们更改Test的声明如下：

class Test{ 
    public:
        Test(BaseTest1& t1, BaseTest2& t2):test1(t1),test2(t2) { }
    public:
        BaseTest2 test2;
        BaseTest1 test1;
    };
    
    
    int main(int argc, char* args[])
    { 
        BaseTest1 test1;
        BaseTest2 test2;
    
        Test test(test1, test2);
    }

那么执行结果如下：

BaseTest1 Constructor
    BaseTest2 Constructor
    BaseTest2 Copy Constructor
    BaseTest1 Copy Constructor

可知Test的构造过程少了BaseTest2的默认构造函数调用，直接通过拷贝构造函数赋值到Test的成员属性。

此外我们还能知道，类成员的初始化顺序与初始化列表的顺序无关，与类里面属性定义的顺序有关。

计算阶段

计算阶段指：执行构造函数体内的赋值操作。

前面我们已经讲过了计算阶段的主要操作，主要是构造函数体里面的逻辑执行，一般来说我们都尽量通过初始化列表初始化成员属性，无法通过初始化列表初始化的操作，就通过构造函数计算阶段执行。

# 为什么使用初始化列表 #

初始化类的成员有两种方式：一是使用初始化列表，二是在构造函数体内进行赋值操作。使用初始化列表主要是基于性能问题，对于内置类型，如int, float等，使用初始化类表和在构造函数体内初始化差别不是很大，但是对于类类型来说，最好使用初始化列表，为什么呢？由上面的测试可知，使用初始化列表少了一次调用默认构造函数的过程，这对于数据密集型的类来说，是非常高效的。同样看上面的例子，我们使用初始化列表来实现Test2的构造函数：

class Test2{ 
    public:
        Test2(Test1& t1);
    private:
        Test1 test1;
    };
    // copy constructor
    Test2::Test2(Test1 &t1):test1(t1){ 
    }

执行同样的main函数：结果如下：

Test1 Constructor
    Test1 Copy Constructor

第一行输出对应调用代码的第一行。第二行输出对应Test2的初始化列表，直接调用拷贝构造函数初始化test1，省去了调用默认构造函数的过程。所以一个好的原则是，能使用初始化列表的时候尽量使用初始化列表。

# C++里面哪些东西必须放在初始化列表里面 #

除了性能问题之外，有些场景初始化列表是不可或缺的，以下几种情况时必须使用初始化列表：

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

比如：

class Test1
    { 
    public:
        Test1(int a):i(a){ }
        int i ;
    };
    
    class Test2
    { 
    public:
        Test1 test1 ;
        Test2(Test1 &t1){ 
            test1 = t1 ;
        }
    };

以上代码无法通过编译，因为Test2类中Test1 test1;需要调用默认的构造函数，但是Test1类没有无参的构造函数，但是由于Test1没有默认的构造函数，故而编译错误。正确的代码如下，使用初始化列表代替赋值操作。

class Test2{ 
        Test1 test1 ;
        Test2(Test1 &t1):test1(t1){ }
    }

# 成员变量的初始化顺序 #

成员是按照他们在类中出现的顺序进行初始化的，而不是按照他们在初始化列表出现的顺序初始化的，看代码。

class foo{ 
        int i ;
        int j ;
        foo(int x):i(x), j(i){ }; // ok, 先初始化i，后初始化j
    };

再看下面的代码：

class foo{ 
        int i ;
        int j ;
        foo(int x):j(x), i(j){ } // i值未定义
    };

这里i的值是未定义的，虽然j在初始化列表里面出现在i前面，但是i先于j定义，所以先初始化i，但i由j初始化，此时j尚未初始化，所以导致i的值未定义。所以，一个好的习惯是，按照成员定义的顺序进行初始化。

# 总结：C++构造函数逻辑执行顺序 #

1.  创建派生类的对象，基类的构造函数优先被调用，（基类的构造函数也优先于派生类里的成员属性类）；
2.  如果类里面有成员属性类，成员属性类的构造函数优先被调用；(成员属性类的构造函数也优先于该类本身的构造函数）
3.  基类构造函数如果有多个基类，则构造函数的调用顺序是某类在类派生表中出现的顺序而不是它们在成员初始化表中的顺序；
4.  成员类对象构造函数如果有多个成员类对象，则构造函数的调用顺序是对象在类中被声明的顺序而不是它们出现在成员初始化表中的顺序；
5.  派生类构造函数，作为一般规则，派生类构造函数应该不能直接向一个基类数据成员赋值而是把值传递给适当的基类构造函数,否则两个类的实现变成紧耦合的（tightly coupled）将更加难于正确地修改或扩展基类的实现。（基类设计者的责任是提供一组适当的基类构造函数）

综上可以得出，初始化顺序：

> 父类构造函数–>成员类对象构造函数(按照类定义顺序而不是初始化列表的顺序)–>类自身构造函数

析构顺序和构造顺序相反。