第2章构造函数语意学-CSDN博客

2.1 默认构造函数的构建操作

　关于C++的默认构造函数的构建是在被需要的时候被编译器产生出来的，关于其中的"被需要的时候"指的是被编译器需要的时候，不包括被程序员需要的时候。其中被编译器需要的时候大致包括以下四种：

　　1. 该类中含有类对象成员(该成员含有默认构造函数)。

　　2. 该类的基类中含有默认构造函数

　　3. 该类中含有虚函数

　　4. 该类在继承体系中存在一个或多个的虚基类。

注：在添加默认构造函数时，如果该类中含有其他构造函数，这些构造函数将会被扩充如：

class B{
    public:
        B(): B_data_member(0){}
    private:
        B_data_member;
}


class A{
    public:
        A(int i = 0){
            A_data_member = i;
        }
    
    private:
        
        B A_data_member;
}

在其进行初始化时会进行下面的操作
    A(){
        A_data_member.B::B();
    }
    A(int i = 0){
        A_data_member.B::B();
        A_data_member = i;
    }

当然在有基类的构造函数进行填充时，基类默认构造函数在其类成员默认构造函数之前，即：基类默认构造函数--->类成员默认构造函数--->该类被执行构造函数内部的相关成员变量的初始化。

2.2 拷贝构造函数的构建操作

将一个对象的内容传给另一个对象，一般大约有三种情况如：赋值，传参，调用函数返回接收。

在对象的初始化过程中，如果以一个对象作为另一个对象的初值时，关于其Data Member将会从一个对象直接赋值到另一个对象中，但是member class object 将会采用递归调用的方式进行赋值，

class A{
    public:
        ...
    private:
        int cnt;
        char *str;
}

在进行赋值时会发生
    A a;
    A b = a;
则会以
    b.cnt = a.cnt;
    b.str = a.str;
的形式进行复制。

关于非Bitwise Copy Semantics(位逐次拷贝)的情况有一下四种：

1. 当一个类中含有另一个类的成员时，且其自身含有一个Copy Constructor(包括程序员自身写的或者由编译器进行合成的)。

2. 该类的基类中含有一个Copy Construcor。

3. 该类中含有Virtual Function。

4. 在继承的体系链中含有Virtual Base Class。

注：与默认构造函数的生成相同。

class A{
    public:
        A(){}
        ~A(){}
        virtual void draw();
        virtual void run();
    private:
        ...
}

class B: public A{
    public:
        B(){}
        ~B(){}
        void draw();
        void run();
    private:
        ...
}


B b;
A a = b;

在最后的赋值中，a的赋值如下图

其中a得到的时A类中的virtual table的地址，但是当采用指针或者引用的方式的时候a才将会只想B中的virtual table，如： A *a = b;

2.3 程序转化语意学

明确的初始化操作

1. 这种初始化的过程大致分为两大类。

　　1.重写每一个定义，其中的初始化操作将被删除。

　　2.类的拷贝构造函数将被添加进去。

T t0;

void foo(){
    T t1(t0);
    T t2 = t0;
    T t3 = T(t0);
}


针对以上t1, t2, t3的将被转化为一下操作

void foo(){
    T t1;
    T t2;
    T t3;
    
    
    t1.T::T(t0);
    t2.T::T(t0);
    t3.T::T(t0);
}

2. 参数的初始化

void foo(T t);


T t1;
foo(t1);

该操作将被转化为
T __Temp; //临时对象
__Temp.T::T(t1);
foo(__Temp);

上述过程为临时对象通过T的拷贝构造函数进行初始化，然后通过位逐位拷贝的形式传给局部参数t。
对于该转化的说明还有一部分，但是目前不是很清晰原因。

　　3. 返回值的初始化

关于返回值的初始化问题大致分为两步

　　1. 首先加上一个额外参数，类型是该类型的返回类型的一个引用，用来放置被"拷贝构建"而得的返回值。

　　2. 在函数的return之前安插一个拷贝构造函数调用操作，以便将欲传回的对象的内容当做上述新增参数的初值。

定义如下
T foo(){
    T t;
    // 相关操作
    return t;
}


该操作将被转化为
void foo(T& __result){
    T t;
    t.T::T();
    __result.T::T(t);
    return;
}

至于foo().member_function()的调用则会转化为
T __Temp;
(foo(__Temp), __Temp).member_function();的操作

4. 在使用者层面做的优化

定义如下
T foo(const P &p1, const P &p2){
    T t;
    // 用p1,p2进行t的相关操作
    return t;
}

在这个定义中会出现逐成员的拷贝到编译器所产生的__result之中，可以在T的内部定义一个构造函数可以直接计算t的值，如：
T foo(const P &p1, const P &p2){
    return T(p1, p2);
}
经这个转化后，比以前的效率要调出一部分。

5. 程序在编译器方面的优化

在能够对一个类进行bitwise方式的初始化时，编译器会在类中进行调用memcpy(this, 0, sizeof(class_name)), 或者进行memset()的操作。如：

class T{
    friend T foo(double);
    public:
        T(){
            memcpy(this, 0, sizeof(T));
        }
    private:
        double array[100];
}

　　如果一个类中有以下四种情况时：

1. 含有一个类成员(其含有默认的构造函数时)。

2. 其base class中含有默认的构造函数时。

3. 含有virtual function时

4. 在继承的体系中含有一个或多个的virtual class时。

仍以bitwise的方式进行初始化会发生错误。如：

class T{
    public:
        T(){
            memcpy(this, 0, sizeof(T));
        }
        
        virtual ~T();
        //...
}
其中的T::T()会被改写为：
T::T(){
    __vptr_T = __vtb1_T;
    memcpy(this, 0, sizeof(T));
}
进而导致__vptr_T被再次进行赋值为0，而丢失它的virtual table

2.4 成员们的初始化队伍

成员初始化时必须要用到初始化列表的情况有：

1.初始化一个引用类型的对象时。

2.初始化一个const 成员时。

3.调用一个基类的构造函数，而且该构造函数具有一组参数时。

4.调用一个类成员的构造函数时，而且该后早函数具有一组参数时。

在类的初始化构造过程中也会发生一些改写。

class T{
    private:
        String _name;
        int _cnt;
    public:
        T(){
            _name = 0;
            _cnt = 0;
        }
};

则被改写为

class T{
    private:
        String _name;
        int _cnt;
    public:
        T(){
            _name.String::String();
            String tmp = String(0);
            _name.String::operator=(tmp);
            tmp.String::~String();
            _cnt = 0;
        }
};

在应用初始化列表时

class T{
    private:
        String _name;
        int _cnt;
    public:
        T(): _name(0){
            _cnt = 0;
        }
};

改写为

class T{
    private:
        String _name;
        int _cnt;
    public:
        T(){
            _name.String::String(0);
            _cnt = 0;
        }
};

　　注：编译器拓展的代码会出现在程序员自己写的代码之前，如：_cnt的赋值之前。

在使用初始化列表进行初始化时注意变量在类内部的声明顺序。

class T{
    private:
        int i;
        int j;
    public:
        T(int val): j(val), i(j) //这里会警告
        {}
};

因为在初始化的过程中先初始化i被初始化为未经初始化的j，而发出警告。

class T{
    private:
        int i;
        int j;
    public:
        T(int val): i(val), j(i)
        {}
};

　　在初始化的过程中也可以调用drived class member function，其返回值可以作为基类构造函数的一个参数

class T: public B{
    private:
        int _fval;
    public:
        int fval(){return _fval}
        T(int val): _fval(val), B(fval){}
};

其中的构造函数会被改写为：
T::T(int val){
    ...
    B::B(this, this->_fval);
    _fval = val;
}