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

以上两种及编译器自动生成的都属于默认构造函数范畴。此外，带参数的构造函数允许在创建对象时为成员传递初始值，灵活性更高。

3. 析构函数与资源清理

析构函数在对象生命周期结束时调用，主要用于释放对象占用的资源。如果你没有定义析构函数，编译器会自动生成一个默认析构函数。但如果类中有动态内存分配或其他资源申请，则需要显式定义析构函数。

析构函数的特点：

• 名称与类名相同，前面加波浪号 ~。
• 没有返回类型，也不能带有参数，因此无法重载。
• 自动调用：局部对象超出作用域时，或动态分配的对象被 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;
};

int main() {
    MyClass obj; // 创建对象时调用构造函数
    return 0;   // 离开作用域时调用析构函数
}

常见的资源清理包括动态内存（使用 new 分配的需 delete）、文件句柄、数据库连接等外部资源。

4. 拷贝构造函数与深拷贝

拷贝构造函数是一个特殊的构造函数，用于通过另一个同类型的对象来初始化一个新对象。如果构造函数的第一个参数是自身类类型的引用，且额外参数都有默认值，则视为拷贝构造函数。

它通常在以下场景被调用：

• 对象作为函数参数传递（按值传递）。
• 从函数返回一个对象。
• 初始化一个对象为另一个同类型对象的副本。

拷贝构造函数的第一个参数必须是类类型对象的引用，使用传值方式会导致无穷递归调用。若未显式定义，编译器生成的默认拷贝构造函数执行浅拷贝（逐字节拷贝）。这意味着指针成员只会复制地址，不会分配新内存，可能导致多个对象共享同一资源，引发内存泄漏。

因此，如果类包含指针成员或动态内存，必须自定义拷贝构造函数以实现深拷贝：

class MyClass {
public:
    int* data;
    MyClass(int val) { data = new int(val); }
    
    // 手动定义深拷贝构造函数
    MyClass(const MyClass& other) {
        data = new int(*other.data);
    }
    
    ~MyClass() { delete data; }
};

注意：如果没有指针成员且不涉及动态内存，可以使用默认的浅拷贝。但一旦涉及资源管理，深拷贝是必须的。

5. 运算符重载

运算符重载允许为自定义类型定义或修改运算符的行为，使对象能像内建类型一样操作。重载运算符本质上是特殊名字的函数，名字由 operator 和符号组成。

5.1 赋值运算符重载

赋值运算符用于完成两个已存在对象之间的拷贝赋值，这与拷贝构造（用于初始化新对象）不同。默认赋值运算符执行浅拷贝，若类涉及动态内存，必须手动实现深拷贝。

实现赋值运算符时需注意：

• 检查自赋值：如果左右对象是同一个，无需操作。
• 释放当前资源：避免内存泄漏。
• 返回 *this：支持链式赋值。

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

5.2 const 成员函数

const 成员函数承诺不会修改对象的状态。它修饰的是隐含的 this 指针。如果在 const 成员函数中尝试修改非 mutable 的成员变量，编译器会报错。这有助于提高代码的安全性和可读性。

例如 Print 函数只读取状态，应声明为 const：

void Print() const {
    cout << _year << "-" << _month << "-" << _day << endl;
}

5.3 mutable 关键字

mutable 允许在 const 成员函数中修改特定的成员变量。常用于缓存、计数器或延迟计算等场景，在不改变对象逻辑状态的前提下更新内部数据。

class MyClass {
public:
    void incrementCounter() const {
        _counter++; // 修改 mutable 成员
    }
private:
    mutable int _counter;
};

5.4 取地址运算符重载

虽然通常不需要重载取地址运算符，但在模拟智能指针或限制获取对象地址等特殊场景下，可以重载 operator& 返回特定地址或 nullptr。

6. 完整的 Date 类实现示例

下面展示一个较为完整的 Date 类实现，涵盖了日期检查、比较运算符、加减运算及流插入/提取运算符的重载。

Date.h

#ifndef DATE_H
#define DATE_H

#include <iostream>
using namespace std;

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;
};

#endif

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;
}

int Date::GetMonthDay(int year, int month) {
    static int ArrMonth[13] = {-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))) {
        return 29;
    }
    return ArrMonth[month];
}

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;
}

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

bool Date::operator<(const Date& d) const {
    if (_year < d._year) return true;
    else if (_year == d._year) {
        if (_month < d._month) return true;
        else if (_month == d._month) return _day < d._day;
    }
    return false;
}

bool Date::operator<=(const Date& d) const {
    return *this < d || *this == d;
}

bool Date::operator>(const Date& d) const {
    return !(*this <= d);
}

bool Date::operator>=(const Date& d) const {
    return !(*this < d);
}

bool Date::operator==(const Date& d) const {
    return _year == d._year && _month == d._month && _day == d._day;
}

bool Date::operator!=(const Date& d) const {
    return !(*this == d);
}

int Date::operator-(const Date& d) const {
    int flag = 1;
    Date max = *this;
    Date min = d;
    if (*this < d) { max = d; min = *this; flag = -1; }
    int count = 0;
    while (min != max) {
        ++min;
        ++count;
    }
    return flag == 1 ? count : -count;
}

Date& Date::operator++() {
    *this += 1;
    return *this;
}

Date Date::operator++(int) {
    Date tmp = *this;
    *this += 1;
    return tmp;
}

Date& Date::operator--() {
    *this -= 1;
    return *this;
}

Date Date::operator--(int) {
    Date tmp = *this;
    *this -= 1;
    return tmp;
}

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

Date Date::operator-(int day) {
    Date tmp = *this;
    tmp -= day;
    return tmp;
}

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;
}

通过以上实现，我们可以看到如何综合运用构造函数、析构函数、拷贝控制以及运算符重载来构建一个健壮且易用的类。在实际开发中，理解这些底层机制对于编写高性能、无内存泄漏的代码至关重要。