非常感激我队友大爹给我的复习资料

凡是有引用类型的成员变量或者常量类型的变量的类，不能有缺省构造函数。

默认构造函数没有对引用成员提供默认的初始化机制，也因此造成引用未初始化的编译错误。

并且必须使用初始化列表进行初始化const对象、引用对象。

直接赋值报错

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{
    private:
        int & a;
        int _b;
    public:
        A(int target, int b) : a(target), _b(b){
            cout << "Constructor Function" << endl;
        }
        // A(int target, int b) {
        //     a = target; 这里会报错
        //     _b = b;
        // }
        void printA(){
            cout << "a is " << a << " b is " << _b << endl; 
        }
};

int main(void){
    int a = 20, a2 = 15;
    A r(a, a2);
    r.printA();
    A r2(a2, a);
    r2.printA();
    return 0;
}

/*
该程序的输出结果为:
===================
Constructor Function
a is 20 b is 15
Constructor Function
a is 15 b is 20
===================
*/

注意，只能使用初始化列表对引用初始化，使用赋值会报错。

对于const修饰的常量，也是同样的道理，只能使用初始化列表来进行初始化。

初始化

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
39
/*
    凡是有引用类型的成员变量或者常量类型的变量的类，不能有缺省构造函数。
    默认构造函数没有对引用成员提供默认的初始化机制，也因此造成引用未初始化的编译错误。
    并且必须使用初始化列表进行初始化const对象、引用对象。
*/
#include <iostream>
using namespace std;

class A{
    private:
        int x;
        int & y;
        const int z;
    public:
        A(int m_x, int m_y, int m_z);
        void printA();
};

// note : 两种方法均正确, 但引用成员和常量成员一定要用初始化列表进行初始化
A::A(int m_x, int m_y, int m_z) : x(m_x), y(m_y), z(m_z){};
A::A(int m_x, int m_y, int m_z) : y(m_y), z(m_z) {
    x = m_x;
}

void A::printA(){
    cout << x << y << z << endl;
}

int main(void){
    A a(1, 2, 3);
    a.printA();
    return 0;
}

/*
====================
    output: 123
====================
*/

再次强调，必须使用初始化列表进行初始化const对象、引用对象。