C++ 类和对象 构造函数(下)

一 初始化列表：

1.1 构造函数体赋值：

在C++中，构造函数用于创建对象并赋予其初始值。通常，我们可以在构造函数体内对成员变量进行赋值：

class Date 
{
public:
    Date(int year, int month, int day)
{
        _year = year;
        _month = month;
        _day = day;
 }
private:
    int _year;
    int _month;
    int _day;
};

上述代码中，构造函数调用之后，对象的成员变量已经有了初始值，但是这种方法并不是真正的初始化，而是赋值。因为初始化只能进行一次，而构造函数体内可以多次赋值。

1.2 初始化列表：

初始化列表是一种在构造函数中初始化成员变量的方式，它在构造函数名之后，用一个冒号开始，接着是以逗号分隔的成员变量列表，每个成员变量后面跟一个放在括号中的初始值或表达式。

class Date 
{
public:
    Date(int year, int month, int day)
        : _year(year), _month(month), _day(day) {} //因{}内部为空时则构造函数体部分没有任何代码
private:
    int _year;
    int _month;
    int _day;
};

为什么要用初始化列表？我举以下列子

const成员变量：

我们先来说说const成员变量的特征：

不可修改：const成员变量一旦被初始化，就不能被修改。这意味着它们的值在对象的生命周期内是固定的。

必须初始化：const成员变量必须在对象创建时被初始化，并且只能初始化一次。

代码示例：

使用初始化列表

class MyClass 
{
public:
    MyClass(int x)
        : _constMember(x) {}  // 使用初始化列表初始化const成员变量
 
private:
    const int _constMember;  // const成员变量
};
 
int main() 
{
    MyClass obj(10);
    return 0;
}

输出：

在构造函数体内赋值

class MyClass 
{
public:
    MyClass(int x)
    {
        _constMember = x;
    }
 
private:
    const int _constMember;  // const成员变量
};
 
int main() 
{
    MyClass obj(10);
    return 0;
}

输出：

为什么const修饰的成员变量只能初始化列表呢？

因为const修饰的成员变量只能在对象创建时直接初始化，这点初始化列表可以满足它 而构造函数体内赋值是默认初始化先给它一个随机值，但是const成员变量只接收一个确定的值，所以不行，那假如说默认初始化给的是确定的值那等结束完默认的初始化那构造函数也会传值过来，这不就进行二次赋值了吗，所以不管怎样都错了

引用成员变量：

我们先来说说引用成员变量的特征：

引用：引用是一个别名，用于引用另一个变量。引用在初始化之后不能再指向其他变量。

必须初始化：引用成员变量在对象创建时必须被初始化，并且只能初始化一次。

代码示例：

使用初始化列表

#include <iostream>
using namespace std;
 
class MyClass 
{
public:
    MyClass(int& ref)
        : _ref(ref) {}  // 使用初始化列表初始化引用成员变量
 
    void print() const 
{
        cout << "Reference value: " << _ref << endl;
}
 
private:
    int& _ref;  // 引用成员变量
};
 
int main() 
{
    int value = 10;
    MyClass obj(value);  // 通过初始化列表初始化引用成员变量
    obj.print();  // 输出: Reference value: 10
 
    return 0;
}

输出：

在构造函数体内赋值

#include <iostream>
using namespace std;
 
class MyClass {
public:
    MyClass(int& ref) {
        _ref = ref;  // 错误：无法在构造函数体内赋值
    }
 
private:
    int& _ref;  // 引用成员变量
};
 
int main() {
    int value = 10;
    MyClass obj(value);  // 编译器报错
    obj.print();
 
    return 0;
}

输出：

_ref = ref; 是错误的，因为 _ref 作为一个引用成员变量，必须在成员初始化列表中进行初始化，不能在构造函数体内重新赋值。

自定义类型成员(且该类没有默认构造函数时)：

#include <iostream>
using namespace std;
 
class Complex {
public:
    Complex(double real, double imag)
        : _real(real), _imag(imag) {}  // 只有一个带参数的构造函数
 
    void print() const {
        cout << "Real: " << _real << ", Imag: " << _imag << endl;
    }
 
private:
    double _real;
    double _imag;
};
 
class MyClass {
public:
    MyClass(double real, double imag, int a, int b)
        :_a(a),  _complex(real, imag)，_b(b) {}  // 使用初始化列表初始化所有成员变量
 
    void print() const {
        _complex.print();
        cout << "_a: " << _a << ", _b: " << _b << endl;
    }
 
private:
    Complex _complex;  // 自定义类型成员变量
    int _a = 0;  // 缺省值
    int _b = 1;  // 缺省值
};
 
int main() {
    MyClass obj(3.0, 4.0, 10, 20);  // 定义对象并初始化成员变量
    obj.print();
 
    return 0;
}

输出：

我们来说说它的执行顺序，顺便来复习复习前面学的知识：

首先为 MyClass 对象的成员变量 _complex、_a 和 _b 分配内存，然后再按照成员变量在 MyClass 类中声明的顺序进行初始化，先是 _complex，然后是 _a 和 _b，调用 Complex 类的构造函数 Complex(real, imag)，在其中为 Complex 对象的成员变量 _real 和 _imag 分配内存并进行初始化，初始化 _a 为 10（通过初始化列表），初始化 _b 为 20（通过初始化列表）。

1.3 初始化与赋值的区别:

在C++中，初始化和赋值是两个不同的概念。初始化是指在对象创建时设置成员变量的初始值，而赋值是指在对象创建之后给成员变量赋予新的值。初始化只能进行一次，而赋值可以多次进行。

初始化

初始化是在对象创建时直接设置成员变量的初始值。例如，通过构造函数的初始化列表进行初始化：

class Date 
{
public:
    Date(int year, int month, int day)
        : _year(year), _month(month), _day(day) {}  // 初始化列表
private:
    int _year;
    int _month;
    int _day;
};
int main() 
{
    Date s(2005, 4 , 26);
    return 0;
}

初始化列表：成员变量在对象创建时直接初始化，没有中间步骤。对于 const 成员变量、引用成员变量以及没有默认构造函数的类类型成员变量，这种方式是唯一的选择。初始化列表的效率更高，因为它避免了先默认初始化然后再赋值的过程。

赋值

赋值是在对象已经创建之后，给成员变量赋予新的值。例如，在构造函数体内进行赋值操作：

class Date 
{
public:
    Date(int year, int month, int day) 
{
        _year = year;
        _month = month;
        _day = day;  // 赋值操作
 }
private:
    int _year;
    int _month;
    int _day;
};
int main() 
{
    Date s(3354, 4 , 6);
    return 0;
}

构造函数体内赋值：成员变量先进行默认初始化，然后在构造函数体内进行赋值。这意味着在进入构造函数体之前，成员变量已经存在了一个初始值（通常是未定义的），然后再赋予新的值。这种方式对于某些类型（如 const 成员变量和引用成员变量）是不可行的，因为这些类型必须在初始化时赋值，而不能通过赋值操作来修改。