C++ 类和对象：默认成员函数详解

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

析构函数

别误会，析构函数不是用来销毁对象本身的，那是系统的事。它主要负责清理对象内部占用的资源，类比之前实现的 Destroy 函数。

注意事项：

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

看个栈的例子，这里涉及动态内存管理：

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

typedef int STDataType;

class Stack {
public:
    Stack(int n = 4) {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (!_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;
};

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++ 规定自定义类型对象进行拷贝行为（如传值传参、传值返回）必须调用拷贝构造。
• 若未显式定义，编译器生成默认拷贝构造函数，对内置类型做浅拷贝，对自定义类型调用其拷贝构造。
• 成员全是内置类型且无资源的类不需要显式实现；有资源的类需要显式实现深拷贝，否则会导致双重释放。

#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) {
        _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();
    
    // 拷贝构造
    Date d2(d1);
    d2.Print();
    
    Date d3 = d2; // 也是拷贝构造
    d3.Print();
    return 0;
}

对于像 Stack 这样有指针成员的类，必须实现深拷贝：

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

深浅拷贝区别：

• 浅拷贝：按字节拷贝，指针只拷贝地址，多个对象共享同一份资源，危险。
• 深拷贝：不仅拷贝指针本身，还对资源重新申请并复制，每个对象独立拥有资源。

赋值运算符重载

赋值运算符用于完成两个已存在对象之间的拷贝赋值。这和拷贝构造不一样，拷贝构造是初始化新对象，赋值是修改已存在对象。

基础规则：

• 运算符重载本质是特殊名字的函数，形式为 operator 运算符。
• 若为成员函数，第一个参数是隐式的 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 修饰的成员函数，放在参数列表后面，实际修饰的是隐含的 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;
};