C++ 类和对象进阶：深入理解默认成员函数与运算符重载

析构函数的命名规则是在类名前加波浪号 ~，没有返回类型，不能带参数，因此无法重载。它由编译器在对象超出作用域或显式调用 delete 时自动调用。

class MyClass {
public:
    MyClass() { ptr = new int[10]; cout << "Constructor: Memory allocated" << endl; }
    ~MyClass() { delete[] ptr; cout << "Destructor: Memory deallocated" << endl; }
private:
    int* ptr;
};

对于局部对象，析构发生在作用域结束；对于动态分配的对象，析构发生在 delete 语句执行时。如果是同一作用域下的多个对象，遵循后进先出的原则。

拷贝构造函数与深浅拷贝

拷贝构造函数是一个特殊的构造函数，用于通过另一个同类型的对象来初始化一个新对象。当对象作为函数参数按值传递、函数返回值或进行拷贝初始化时，都会调用它。

拷贝构造函数的第一个参数必须是类类型对象的引用，且后续参数必须有默认值。如果未显式定义，编译器会生成默认的拷贝构造函数，执行浅拷贝（逐字节复制）。这意味着指针成员只会复制地址，导致多个对象共享同一块内存，极易引发双重释放错误。

class MyClass {
public:
    int* data;
    MyClass(int val) { data = new int(val); }
    // 默认拷贝构造函数是浅拷贝
    ~MyClass() { delete data; }
};

如果类涉及动态内存，必须自定义拷贝构造函数实现深拷贝，为每个对象分配独立的内存空间。

MyClass(const MyClass& other) {
    data = new int(*other.data);
}

运算符重载实战

运算符重载允许我们修改运算符的行为，使自定义类型能像内置类型一样使用。重载后的运算符优先级和结合性与内置类型一致。

基本规则

• 重载运算符函数名由 operator 和符号组成。
• 一元运算符有一个参数，二元运算符有两个参数。
• 作为成员函数时，左侧运算对象传给隐式的 this 指针。
• 部分运算符如 .*, ::, sizeof 等不可重载。
• 后置 ++ 需要增加一个 int 形参以区分前置 ++。
• << 和 >> 通常需重载为全局函数，以便将流对象放在第一个参数位置。

class Date {
public:
    bool operator==(const Date& d) {
        return _year == d._year && _month == d._month && _day == d._day;
    }
    Date& operator++() { /* 前置 */ return *this; }
    Date operator++(int) { /* 后置 */ return Date(); }
private:
    int _year, _month, _day;
};

赋值运算符重载

赋值运算符用于两个已存在对象之间的拷贝。默认实现也是浅拷贝，涉及动态内存时必须手动实现深拷贝。实现时需注意检查自赋值、释放旧资源、执行深拷贝并返回 *this 以支持链式赋值。

Date& operator=(const Date& d) {
    if (this != &d) {
        _year = d._year; _month = d._month; _day = d._day;
    }
    return *this;
}

const 成员函数与 mutable

const 成员函数承诺不修改对象状态，实际修饰的是隐含的 this 指针。这有助于编译期检查和代码安全性。但在某些场景下（如缓存、计数器），我们需要在 const 函数中修改特定成员，这时可以使用 mutable 关键字。

class MyClass {
public:
    void incrementCounter() const { _counter++; } // 合法
private:
    mutable int _counter;
};

取地址运算符重载

虽然很少见，但可以重载 & 运算符。通常直接返回 this 指针。在某些特殊场景（如模拟智能指针或限制获取地址）下，可以返回特定地址或 nullptr。

完整的 Date 类实现示例

下面是一个整合了上述概念的完整 Date 类实现，包含了日期检查、比较运算符重载及输入输出流重载。

Date.h

class Date {
    friend ostream& operator<<(ostream& out, const Date& d);
    friend istream& operator>>(istream& in, Date& d);
public:
    Date(int year = 2005, int month = 5, int day = 18);
    bool DateCheck();
    void print();
    int GetMonthDay(int year, int month);
    bool operator<(const Date& d) const;
    bool operator<=(const Date& d) const;
    bool operator>(const Date& d) const;
    bool operator>=(const Date& d) const;
    bool operator==(const Date& d) const;
    bool operator!=(const Date& d) const;
    Date& operator+=(int day);
    Date operator+(int day);
    Date& operator-=(int day);
    Date operator-(int day);
    int operator-(const Date& d) const;
    Date& operator++();
    Date operator++(int);
    Date& operator--();
    Date operator--(int);
private:
    int _year;
    int _month;
    int _day;
};

Date.cpp

#include "Date.h"

bool Date::DateCheck() {
    if (_month < 1 || _month > 12 || _day < 1 || _day > GetMonthDay(_year, _month)) {
        return false;
    }
    return true;
}

Date::Date(int year, int month, int day) {
    _year = year; _month = month; _day = day;
    if (!DateCheck()) {
        cout << "日期非法" << endl;
        print();
    }
}

void Date::print() {
    cout << _year << "/" << _month << "/" << _day << endl;
}

Date& Date::operator+=(int day) {
    if (day < 0) return this->operator-=(-day);
    _day += day;
    while (_day > GetMonthDay(_year, _month)) {
        _day -= GetMonthDay(_year, _month);
        ++_month;
        if (_month == 13) {
            ++_year; _month = 1;
        }
    }
    return *this;
}

// ... 其他运算符实现省略，逻辑同上 ...

ostream& operator<<(ostream& out, const Date& d) {
    out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
    return out;
}

istream& operator>>(istream& in, Date& d) {
    while (1) {
        cout << "请依次输入年月日:";
        in >> d._year >> d._month >> d._day;
        if (!d.DateCheck()) {
            cout << "输入日期非法:";
            d.print();
            cout << "请重新输入!!!" << endl;
        } else {
            break;
        }
    }
    return in;
}

掌握这些机制，能让你编写的 C++ 类更加健壮、符合 RAII 原则，并能提供直观的用户体验。在实际开发中，合理运用默认成员函数和运算符重载，往往能让代码简洁而高效。