C++ 类与对象：深入解析默认成员函数

大多数情况下，我们需要自己实现构造函数。只有少数情况，如类的成员都是自定义类型且这些自定义类型有合适的默认构造函数时（比如用两个 Stack 实现队列），编译器自动生成的构造函数才够用。

析构函数详解

很多人容易误解析构函数是用来销毁对象的，其实对象生命周期结束会自动销毁，它主要负责清理资源，类比之前实现的 Destroy 函数。

析构函数的特点：

• 析构函数名是在类名前加上 ~
• 无参数无返回值（不需要写 void）
• 一个类只能有一个析构函数，若未显式定义，系统会自动生成
• 对象生命周期结束时，系统会自动调用析构函数
• 编译器自动生成的析构函数对内置类型成员不做处理，对自定义类型成员会调用其析构函数
• 即使显式定义了析构函数，自定义类型成员的析构函数也会被自动调用
• 没有申请资源的类（如 Date）可以不写析构函数；有资源申请的类（如 Stack）必须自己写析构函数，否则会造成资源泄漏
• 局部域的多个对象，后定义的先析构

#include <iostream>
#include <cstdlib>
using namespace std;

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() {
        cout << "~Stack()" << endl;
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }
private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

// 两个 Stack 实现队列
class MyQueue {
public:
    // 编译器默认生成的析构函数会调用 Stack 的析构函数
    ~MyQueue() {
        cout << "~MyQueue()" << endl;
    }
private:
    Stack pushst;
    Stack popst;
};

int main() {
    Stack st;
    MyQueue mq;
    // 析构顺序：~MyQueue() -> ~Stack()(popst) -> ~Stack()(pushst) -> ~Stack()(st)
    return 0;
}

拷贝构造函数与深拷贝

拷贝构造函数是一种特殊的构造函数，用于用一个已存在的对象初始化一个新创建的对象。

拷贝构造函数的特点：

• 是构造函数的一个重载
• 第一个参数必须是自身类类型对象的引用，使用传值方式会引发无穷递归调用
• 可以有多个参数，但后续参数必须有缺省值
• C++ 规定自定义类型对象进行拷贝行为必须调用拷贝构造（如传值传参、传值返回）
• 若未显式定义，编译器会生成默认拷贝构造函数，对内置类型成员进行值拷贝 / 浅拷贝，对自定义类型成员调用其拷贝构造
• 成员全是内置类型且无资源的类（如 Date）不需要显式实现
• 有资源的类（如 Stack）需要显式实现深拷贝，否则会导致双重释放
• 传值返回会产生临时对象并调用拷贝构造；传引用返回可减少拷贝，但需确保返回对象在函数结束后仍存在

#include <iostream>
using namespace std;

class Date {
public:
    Date(int year = 1, int month = 1, int day = 1) {
        _year = year;
        _month = month;
        _day = day;
    }
    
    // 拷贝构造函数
    Date(const Date& d) // 使用 const 引用避免修改原对象
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    
    void Print() {
        cout << _year << "/" << _month << "/" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main() {
    Date d1(2025, 11, 30);
    d1.Print(); // 2025/11/30
    
    // 拷贝构造
    Date d2(d1);
    d2.Print(); // 2025/11/30
    
    Date d3 = d2; // 也是拷贝构造
    d3.Print(); // 2025/11/30
    return 0;
}

深拷贝实现（以 Stack 为例）

对于包含指针成员的类，简单的字节拷贝是不够的。

// 栈的深拷贝构造
Stack(const Stack& st) {
    // 对指针指向的资源重新申请空间并复制数据
    _a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
    if (nullptr == _a) {
        perror("malloc 申请空间失败!!!");
        return;
    }
    memcpy(_a, st._a, sizeof(STDataType) * st._top);
    _top = st._top;
    _capacity = st._capacity;
}

深 / 浅拷贝区别

• 浅拷贝：按字节拷贝，对于指针成员只拷贝地址，不拷贝资源，可能导致多个对象共享同一份资源
• 深拷贝：不仅拷贝指针本身，还对指针指向的资源重新申请空间并复制数据，每个对象拥有独立的资源

赋值运算符重载

赋值运算符重载用于完成两个已存在对象之间的拷贝赋值，与拷贝构造的区别是：拷贝构造用于用已有对象初始化新对象，而赋值重载用于两个已存在对象之间的赋值。

运算符重载基础：

• 运算符重载是具有特殊名字的函数，形式为 operator 运算符
• 重载运算符的参数个数与运算对象数量一致，一元运算符 1 个参数，二元运算符 2 个参数
• 若为成员函数，第一个参数为隐式的 this 指针，因此参数比运算对象少一个
• 不能重载的运算符：.*、::、sizeof、?:、.
• 重载操作符至少有一个类类型参数
• 前置 ++ 和后置 ++ 的区分：后置 ++ 重载时增加一个 int 形参
• << 和 >> 建议重载为全局函数，以符合使用习惯

赋值运算符重载的特点：

• 必须重载为成员函数
• 参数建议为 const 当前类类型引用，避免传值拷贝
• 返回值建议为当前类类型引用，支持连续赋值
• 未显式实现时，编译器会生成默认赋值重载，行为与默认拷贝构造类似（内置类型浅拷贝，自定义类型调用其赋值重载）
• 有资源的类需要显式实现深拷贝的赋值重载

// 赋值运算符重载
Date& operator=(const Date& d) {
    // 避免自己给自己赋值
    if (this != &d) {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    return *this; // 支持连续赋值
}

// 使用示例
int main() {
    Date d1(2025, 11, 30);
    Date d2(2025, 12, 1);
    d1 = d2;      // 赋值重载，两个已存在对象
    Date d3(d2);  // 拷贝构造，用 d2 初始化新对象 d3
    Date d4 = d2; // 拷贝构造，不是赋值
    return 0;
}

取地址运算符重载

取地址运算符重载分为普通取地址和 const 取地址两种，一般情况下编译器自动生成的即可满足需求，不需要显式实现。

const 成员函数

const 成员函数是指用 const 修饰的成员函数，const 放在参数列表后面，实际修饰的是隐含的 this 指针，表明在该函数中不能修改类的任何成员。

// const 成员函数示例
void Print() const // 实际为 void Print(const Date* const this)
{
    cout << _year << "-" << _month << "-" << _day << endl;
}

取地址运算符重载示例

class Date {
public:
    // 普通取地址运算符重载
    Date* operator&() {
        return this; // return nullptr; // 可以自定义返回值
    }
    
    // const 取地址运算符重载
    const Date* operator&() const {
        return this; // return nullptr; // 可以自定义返回值
    }
private:
    int _year; // 年
    int _month; // 月
    int _day; // 日
};