C++ 构造函数的重载、缺省构造函数、类型转换构造函数、拷贝构造函数

1. 缺省构造函数

• 只要对象被创建，就会调用构造函数。 如果类中没有定义构造函数，编译器会自动给一个无参缺省构造函数。
• 构造时，一定先构造成员子对象

1.1 代码示例

#include <iostream>
using namespace std;

// 这里A类中已经构造函数，那么编译器不会再提供缺省构造函数
class A {
public:
    A(void){
        cout << "无参构造函数" << endl;
        m_i = 0;  
    }
    int m_i;
};

// B类中没有构造函数，编译器在编译B类时，会自动添加一个缺省的无参构造函数
class B {
public:
    // 构造函数对基本类型的成员变量， 不做初始化
    int m_j;
    // 对类类型成员变量（成员子对象），将自动调用相应类的缺省构造函数来初始化
    A m_a;   
};

int main(void){
    // 用B类以无参的方式实例化一个对象，创建对象就一定会用到构造函数
    // 但B类中没有构造函数， 编译器会自动给一个缺省的无参构造函数
    B b;
    cout << b.m_j << endl; //没有做初始化，结果未知
    cout << b.m_a.m_i << endl; //0 
    return 0;
}

$ ./a.out 
无参构造函数	# A类的构造函数
-718891504  # 没有做初始化，结果未知
0

2. 类型转换构造函数

• 一般构造函数参数只有一个的话，它都可以实现将参数类型转换为当前类类型的对象。

2.1 代码示例

#include <iostream>
using namespace std;

class Integer {
public:
    Integer(void){
        cout << "Integer(void)" << endl;
        m_i = 0;
    }
    
    // 类型转换构造函数
    // 本例子中，实现把一个整型数据转换成Integer类类型
    /*explicit*/ Integer(int i){
        cout << "Integer(int)" << endl;
        m_i = i;
    }
    void print(void){
        cout << m_i << endl;
    }
private:
    int m_i;
};

int main(void){
    Integer i;
    i.print(); // 0
    // 1. 隐式转换
    // i是类类型的对象，而100是一个基本类型变量。但是100必须要转成Integer类类型才能对i进行初始化
    // 编译器会从Integer找到有参构造函数，将100当做实参，构造出一个Integer类型的临时对象，所以又会调用一次构造函数
    // 再用这个临时对象对i进行初始化，  隐式： 编译器会把 i = 100; => i = Integer(100);
    i = 100;
    i.print(); // 100

    // 2. 显示转换, 跟上面做的事是一样的
    // 如果 Integer(int i) 前加了explicit，那么必须显示
    // 从语感角度来理解： 用Integer实例化一个匿名对象，再用匿名对象对i初始化
    i = Integer (200);
    i.print(); // 200

    return 0;
}

Integer(void) # Integer i;
0
Integer(int) # i = 100;
100
Integer(int) # i = Integer(200);
200

3. 拷贝构造函数

• const， 可以防止意外地修改源对象。也可以接收常类型的对象
• &，可以提高传参效率，并且如果不加，会发生实参到形参的拷贝操作，这样就又会调用拷贝构造函数，发生死递归的情况, 当然编译器也不允许不加&。

3.1 代码示例

#include <iostream>
using namespace std;

class A{
public:
    A(int data = 0) {
        cout << "A(int)" << endl;
        m_data = data;
    }
    // 拷贝构造函数
    // 如果这里没有&，就会有实参到形参的拷贝（也就是对象到对象的拷贝, 又会调用拷贝构造函数， 发生死递归）
    A(const A& that) {
        cout << "A(const A&)" << endl;
        m_data = that.m_data;
    }
    int m_data;
};

int main(void){
    A a1(100);
    // 拷贝构造, 用已经存在的对象a1作为构造实参实例化对象a2
    // 1. 写法1
    A a2(a1); 

    // 2. 写法2
    // 要像上面那样理解，不能把=当做赋值操作
    A a3 = a1;
    cout << a1.m_data << endl;
    cout << a2.m_data << endl;
    cout << a3.m_data << endl;
    return 0;
}

$ ./a.out 
A(int)
A(const A&)
A(const A&)
100
100
100

4. 缺省拷贝构造函数

4.1 代码示例

#include <iostream>
using namespace std;

class A{
public:
    // 缺省构造函数
    A(int data = 0) {
        cout << "A(int)" << endl;
        m_data = data;
    }
    // 拷贝构造函数
    // 如果这里没有&，就会有实参到形参的拷贝（也就是对象到对象的拷贝, 又会调用拷贝构造函数， 发生死递归）
    A(const A& that) {
        cout << "A(const A&)" << endl;
        m_data = that.m_data;
    }
    int m_data;
};

// B中没有定义构造函数，和拷贝构造函数，编译器会给分配缺省的
class B{
public:
    A m_a; //成员子对象
};

int main(void){
    // 调用B的缺省构造函数实例化一个对象b1
    // 对于成员子对象m_a, 将会调用A中的缺省构造函数
    B b1;
    cout << b1.m_a.m_data << endl; // 0
    
    // 调用B的缺省拷贝构造函数实例化一个对象b2
    // 对于成员子对象m_2, 将会调用A中的相应类型的拷贝构造函数,完成拷贝初始化
    B b2(b1);
    cout << b2.m_a.m_data << endl; // 0
    return 0;
}

$ ./a.out 
A(int)
0
A(const A&)
0

总结

• c++类中有一个对象自恰性设计思想，对于B类中所包含的成员子对象，子对象的所有操作都应该由类型的提供者（B？）来完成。
• 以无参的方式创建了b1，那么子对象m_a也会以无参方式创建。以拷贝的方式创建了b2，那么子对象m_a也会以拷贝方式创建。

5. 拷贝构造函数的调用时机

5.1 代码示例

#include <iostream>
using namespace std;

class A{
public:
    A(void){
        cout << "A的无参构造" << endl;
    }
    A(const A& that){
        cout << "A的拷贝构造函数" << endl;
    }
};

// 参数是A类型对象的函数 
void func(A a){}

// 返回值是A类型对象的函数
A bar(void){
    A a;
    cout << &a << endl;
    // 把函数返回结果a 拷贝给 临时对象保存，会用到拷贝构造函数
    return a;
}

int main(void){
    A a1; // 无参构造 1次
    A a2 = a1; // 拷贝构造 1次 
    func(a1); // 拷贝构造(传参) 1次
    A a3 = bar(); // 无参构造(bar 中)，拷贝构造(bar 中，a到临时对象)，拷贝构造(临时对象到a3) 3次
    cout << &a3 << endl;
    return 0;
}

$ ./a.out 
A的无参构造
A的拷贝构造函数
A的拷贝构造函数
A的无参构造
# 编译器会让a3直接引用a, a3就是a的别名。这样就少使用了两次拷贝构造函数。#NRV,参考《深度探索Ｃ++对象模型》
0x7ffce5d15ac7
0x7ffce5d15ac7

去优化就正常了

$ g++ a.cpp -fno-elide-constructors
$ ./a.out 
A的无参构造
A的拷贝构造函数
A的拷贝构造函数
A的无参构造
0x7ffdd3cd9237
A的拷贝构造函数
A的拷贝构造函数
0x7ffdd3cd9256