C++ 类与对象进阶：默认成员函数与操作符重载

生成条件：你的类中没有定义任何默认构造函数。

这遵循一种机制：如果你没写构造函数，编译器会生成一个默认无参的；一旦你自己写了任意一个（哪怕是带参数的），编译器就会停止赠送默认构造函数。

class A { 
    // 什么都没写 -> 编译器生成 A()
}; 

class B {
public:
    B(int x) { cout << x << endl; } 
    // 你写了一个带参构造 -> 编译器不再生成 B()
}; 

int main() {
    B b;      // 错误写法，此时类中只含有一个带实参的构造函数
    B b(1);   // 正确写法
    return 0;
}

执行逻辑： C++ 把类型分成内置类型（基本类型）和自定义类型。

• 对待'自定义类型'：如果你的类里包含其他的类对象，编译器生成的构造函数会自动调用这些成员的默认构造函数。
• 对待'内置类型'：对于基础数据类型，编译器默认生成的构造函数什么都不做，这意味着这些变量的内存里原来是什么垃圾数据，现在还是什么。

typedef int STDataType;
class Stack {
public:
    Stack(int n = 4) {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (nullptr == _a) {
            perror("malloc 申请空间失败");
            return;
        }
        _capacity = n;
        _top = 0;
    }
private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

class MyQueue {
public:
    // 编译器默认生成 MyQueue 的构造函数调用了 Stack 的构造，完成了两个成员的初始化
private:
    Stack pushst;
    Stack popst;
};

int main() {
    MyQueue mq; // 编译器生成的构造函数，调用了 Stack 的默认构造函数
    return 0;
}

如果在 Stack 类中删除了显式定义的构造函数，代码虽然能编译通过，但运行时处于危险状态。指针 _a 会变成野指针，存储的是内存中的随机值，没有指向有效的堆内存地址。

结论：永远不要信任编译器默认生成的构造函数来处理内置类型如 int、bool 或指针等。

1.5 小结

1. 名称与类名相同。
2. 没有返回值，连 void 都不用写。
3. 自动调用，不需要手动调用。
4. 可以重载，只要参数列表不同即可。
5. 如果类中没有显式定义构造函数，则 C++ 编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
6. 无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数，但有且只有一个存在。

二、拷贝构造函数

简单来说，它的作用是'克隆'：用一个已存在的对象来初始化一个新对象。

2.1 核心语法

class ClassName {
public:
    // 语法：类名 (const 类名& 别名)
    ClassName(const ClassName& other) {
        // 在这里做拷贝工作
    }
};

关键点：

1. 引用 & 是必须的：如果不传引用而是传值，传参过程本身又要拷贝，就会无限递归调用拷贝构造函数，导致栈溢出。
2. const 通常要加：保证在拷贝过程中，不会意外修改那个'原件'。

2.2 为什么必须加引用？

如果去掉了 &，假设我们将拷贝构造函数写成 Date(Date d)，通过调用拷贝构造函数让对象 d1 初始化新对象 d2。

1. 程序执行 Date d2(d1)，准备调用拷贝构造函数。
2. 系统发现拷贝构造函数 Date(Date d) 的参数是 Date d（按值传递）。
3. 为了调用这个函数，系统必须先把实参 d1 复制给形参 d。
4. 如何复制 d1 给 d 呢？系统必须调用 Date 的拷贝构造函数。
5. 结果：这就形成了一个无限递归调用。

当你加上 &，变成 Date(const Date& d) 时，引用传递的含义是形参 d 只是实参 d1 的一个别名。传递参数时，不需要创建新的副本，也不需要分配新的内存，只是把 d1 的地址/身份传进去了。既然不需要创建新对象，就不会触发'拷贝'动作，也就不会再次调用拷贝构造函数。

2.3 特性与场景

C++ 规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。

• 传值传参：本质是用实参初始化形参。例如 void func(Student s)，调用 func(s1) 时，编译器必须调用拷贝构造函数 Student(const Student&)。
• 传值返回：当函数返回一个对象时，局部变量在函数结束时就会销毁，所以通过'拷贝'把值传出去。这会涉及临时匿名对象的创建和两次拷贝。

2.4 编译器默认生成的拷贝构造

若未显式定义拷贝构造，编译器会自动生成。

• 对内置类型成员变量：会完成值拷贝（浅拷贝，即一个字节一个字节的拷贝）。
• 对自定义类型成员变量：会调用它的拷贝构造。

class Wallet {
public:
    Wallet() {}
    Wallet(const Wallet& w) {
        cout << "【自定义类型】Wallet 的拷贝构造被调用了！" << endl;
    }
};

class Person {
public:
    int age; // 内置类型
    int* scorePtr; // 内置类型
    Wallet myWallet; // 自定义类型
    // 这里我们【不写】拷贝构造函数，编译器会自动生成一个
};

int main() {
    Person p1;
    p1.age = 18;
    int score = 100;
    p1.scorePtr = &score;
    cout << "--- 开始拷贝 ---" << endl;
    Person p2 = p1; // 触发编译器生成的默认拷贝构造
    cout << "p1 的成绩地址：" << p1.scorePtr << " " << "p2 的成绩地址：" << p2.scorePtr << endl;
    cout << "--- 拷贝结束 ---" << endl;
    return 0;
}

输出验证：

1. Wallet 的拷贝构造被打印 -> 证明自定义类型调用了它的拷贝构造。
2. p2.age 等于 18 -> 证明内置类型进行了值拷贝。
3. p2.scorePtr 的地址 等于 p1.scorePtr -> 证明指针只拷贝了地址（浅拷贝）。

2.5 浅拷贝与深拷贝

浅拷贝：C++ 编译器默认的复制行为，按位拷贝。对于普通成员变量没有问题，但对于指针成员变量，只复制了指针本身（内存地址），而没有复制指针指向的数据。

对于像 Stack 这样使用内置类型但涉及资源管理（如指针 _a 指向资源）的类，浅拷贝会出现严重缺陷：

1. 数据共享冲突：两个对象指向同一块内存。
2. 重复释放：当两个对象生命周期结束时，析构函数都会尝试释放同一块内存，造成程序崩溃。

深拷贝：为了克服浅拷贝的局限性，采用深拷贝机制。

1. 为新对象分配独立的内存空间。
2. 将原对象指针指向的数据完整复制到新内存中。
3. 使新对象的指针指向新分配的内存区域。

typedef int STDataType;
class Stack {
public:
    Stack(int n = 4) {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (nullptr == _a) {
            perror("malloc 申请空间失败");
            return;
        }
        _capacity = n;
        _top = 0;
    }
    Stack(const Stack& st) {
        // 需要对_a 指向资源创建同样大的资源再拷贝值
        _a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
        if (nullptr == _a) {
            perror("malloc 申请空间失败!!!");
            return;
        }
        memcpy(_a, st._a, sizeof(STDataType) * st._top);
        _capacity = st._capacity;
        _top = st._top;
    }
    ~Stack() {
        free(_a);
        _a = nullptr;
    }
private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

int main() {
    Stack st1;
    Stack st2 = st1; // 深拷贝
    return 0;
}

2.6 小结

1. 拷贝构造函数是构造函数的一种重载形式。
2. 第一个参数必须是类类型对象的引用。若采用传值方式，会引发无限递归调用。
3. C++ 规定自定义类型对象进行拷贝时必须调用拷贝构造函数。
4. 如果未显式定义拷贝构造函数，编译器会自动生成一个。自动生成的拷贝构造函数会对内置类型成员变量进行值拷贝（浅拷贝），对自定义类型成员变量则会调用其拷贝构造函数。
5. 对于像 Date 这样仅包含内置类型成员且不涉及资源管理的类，编译器自动生成的拷贝构造函数即可满足需求。
6. 但对于像 Stack 这样涉及资源管理的类，自动生成的浅拷贝无法满足需求，需要手动实现深拷贝。
7. 传值返回会通过拷贝构造函数生成临时对象，而传引用返回则直接返回对象的引用（别名），不会产生拷贝。

三、析构函数

析构函数是面向对象编程中的一个核心概念，简单来说，它是构造函数的'反义词'。如果说构造函数是'对象出生时的初始化'，那么析构函数就是'对象临终前的清理'。

3.1 核心语法

1. 名称与类名相同，但在前面加一个波浪号 ~。
2. 没有返回值，也没有类型。
3. 不接受任何参数（因此析构函数不能被重载，一个类只能有一个析构函数）。

class MyClass {
public:
    MyClass() { /* 初始化代码 */ }
    ~MyClass() { /* 清理代码 */ }
};

3.2 调用条件

• 离开作用域：在函数内部定义的局部变量，当函数执行完毕或遇到右大括号 } 时。
• delete 操作：当你拥有一个指向堆对象的指针，并显式调用 delete pointer 时进行析构函数的调用。

3.3 编译器默认生成的析构函数

生成条件：你的类中没有定义任何析构函数。

行为逻辑：

• 对待'自定义类型'：如果你的类里包含其他的类对象，编译器生成的析构函数会自动调用这些成员的析构函数。
• 对待'内置类型'：对于基础数据类型，编译器默认生成的析构函数什么都不做。

特别注意：编译器生成的默认析构函数回收了栈区的 _a（那把钥匙），堆区的那块内存（那个房间）依然被标记为'占用'，但因为钥匙没了，你再也无法访问它，也无法释放它，这就导致了内存泄漏。

3.4 调用顺序

• 同一作用域的局部对象：后进先出 (LIFO)。后定义的对象先析构。
• 数组对象：数组元素的析构顺序与构造顺序严格相反。构造顺序从小到大，析构顺序从大到小。
• 局部静态对象和全局对象：全局对象在 main 开始前出生，main 结束后销毁。静态对象第一次运行到定义处出生，main 结束后销毁。

3.5 小结

1. 析构函数名由类名前加波浪号 ~ 构成。
2. 无参数且无返回值。
3. 每个类只能有一个析构函数。若未显式定义，编译器会自动生成默认析构函数。
4. 当对象生命周期结束时，系统会自动调用其析构函数。
5. 与构造函数类似，编译器生成的默认析构函数对内置类型成员不做处理，但会调用自定义类型成员的析构函数。
6. 显式定义的析构函数同样会调用自定义类型成员的析构函数。
7. 当类未申请资源时，可以不写析构函数而使用编译器生成的默认版本；若默认析构函数已满足需求，也无需显式定义。但涉及资源申请时，必须自定义析构函数以避免资源泄漏。

四、操作符重载

4.1 核心概念

操作符重载让你能够为自定义类型重新定义运算符的行为。这项功能的主要价值在于提升代码可读性，让自定义类型的使用体验与内置类型一样自然直观。

本质上，操作符重载只是函数调用的一种语法糖。

4.2 运算符重载语法

语法规则：返回类型 + 关键字 operator + 操作符 + 参数。

• 返回类型：可以是 void、int、bool、返回'引用'、返回'对象'等。
• 关键字和操作符：必须是 operator 加上 C++ 现有的符号。
• 参数：重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。

有 5 个特殊的符号，绝对禁止重载：.、::、sizeof、?:、.*。

4.3 全局函数和成员函数

全局函数的运算符重载：

• 所有操作数都必须通过参数显式传递。
• 双目运算符需要 2 个参数。
• 缺陷：会面临对象访问私有成员变量的问题。

成员函数的运算符重载：

• 运算符左侧的操作数会自动成为调用该函数的对象（即 this 指针指向的对象）。
• 双目运算符只需要 1 个参数。

选择建议：

1. 必须用成员函数：=, [], (), ->。
2. 必须用全局函数：<<, >>（流插入/提取）。原因：cout << p 的左操作数是 ostream 系统类，无法修改其源码。
3. 建议用全局函数：二元算术运算符 (+, -, *, /)，比较运算符 (==, !=, <)。这样可以保持操作数的对称性。
4. 建议用成员函数：复合赋值运算符 (+=, -=, *=)。因为通常会改变自身状态。

4.4 特殊运算符重载

前置 ++ 和后置 ++：

• 前置 ++：先加后用。返回引用，支持链式调用。原型：Type& operator++()。
• 后置 ++：先用后加。区分标志是额外添加一个 int 类型的形参。返回旧值的副本。原型：Type operator++(int)。

流插入 << 和流提取 >>：

• 必须实现为全局函数，并通常声明为类的友元（friend）。
• 流插入原型：ostream& operator<<(ostream& out, const Type& obj)。
• 流提取原型：istream& operator>>(istream& in, Type& obj)。

4.5 赋值运算符重载

用于实现两个已存在对象之间的拷贝赋值。它与拷贝构造函数的区别在于：拷贝构造函数用于在创建新对象时初始化，赋值运算符用于已存在对象之间。

核心语法：ClassName& operator=(const ClassName& 参数名)。

注意事项：

1. 检查自己给自己赋值的情况 (if (this == &d))。
2. 返回 *this 以支持链式赋值。

五、总结：三法则 (Rule of Three)

C++ 有一个著名的原则：如果你需要显式定义以下其中一个，你通常需要定义全部三个：

1. 析构函数 (Destructor)
2. 拷贝构造函数 (Copy Constructor)
3. 拷贝赋值运算符 (Copy Assignment Operator)

这是因为它们都涉及到资源的获取与释放。如果类中包含动态分配的资源（如指针），这三个函数必须协同工作以确保资源安全。