C++ 深入：类与对象的默认成员函数及运算符重载

注意：通过无参构造函数创建对象时，对象后面不用跟括号，否则编译器无法区分这里是函数声明还是实例化对象。

特殊运用：队列中的构造

当类中包含自定义类型的成员变量时，构造函数的调用顺序很重要。

typedef int STDataType;
class Stack {
public:
    // 默认构造函数
    Stack(int n = 4) {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (_a == nullptr) {
            perror("malloc fail");
            return;
        }
        _capacity = n;
        _top = 0;
    }
private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

class MyQueue {
public:
    // 编译器默认生成 MyQueue 的构造函数，会依次调用 pushst 和 popst 的构造
private:
    Stack pushst;
    Stack popst;
};

int main() {
    MyQueue mq;
    return 0;
}

析构函数

析构函数与构造函数功能相反，负责对象生命周期结束时的资源清理。它不是销毁对象本身，而是释放对象占用的资源。

析构函数的特点：

• 函数名是类名前加 ~。
• 无参数、无返回值。
• 一个类只能有一个析构函数。
• 未显式定义时，系统自动生成默认析构函数。

对于内置类型成员，默认析构不做处理；对于自定义类型成员，会调用其析构函数。如果类中申请了资源（如 malloc），必须手动编写析构函数释放，否则会造成内存泄漏。

析构函数运用

typedef int STDataType;
class Stack {
public:
    Stack(int n = 4) {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (_a == nullptr) {
            perror("malloc fail");
            return;
        }
        _capacity = n;
        _top = 0;
    }
    
    ~Stack() {
        free(_a);
        _a = nullptr; // 修复原代码笔误
        _capacity = _top = 0;
    }
private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

class MyQueue {
public:
    // 编译器默认生成析构函数，会调用 Stack 的析构释放内部资源
private:
    Stack pushst;
    Stack popst;
};

int main() {
    MyQueue mq;
    return 0;
}

拷贝构造函数

如果一个构造函数的第一个参数是自身类类型的引用，且后续参数都有默认值，它就是拷贝构造函数。它是构造函数的一个重载。

关键点：

• 第一个参数必须是类类型对象的引用，传值会导致无穷递归。
• 若未显式定义，编译器生成默认拷贝构造（浅拷贝）。
• 对内置类型成员完成值拷贝，对自定义类型成员调用其拷贝构造。

何时需要自己实现？

1. Date 类：全是内置类型，无需资源管理，默认拷贝构造够用。
2. Stack 类：包含指针指向堆内存，默认浅拷贝会导致析构时重复释放，需实现深拷贝。
3. MyQueue 类：成员是自定义类型 Stack，编译器生成的拷贝构造会调用 Stack 的拷贝构造，若 Stack 已正确实现，MyQueue 可沿用默认。

小技巧：如果一个类显式实现了析构并释放资源，通常也需要显式实现拷贝构造。

常见误区：无穷递归

错误写法（传值）

class Date {
public:
    // 错误：参数为 Date d 而非 const Date& d
    // 调用 d2(d1) 时会先拷贝 d1 给形参 d，这又需要调用拷贝构造，导致死循环
    Date(const Date d) { _year = d._year; _month = d._month; _day = d._day; }
private:
    int _year, _month, _day;
};

正确写法（引用）

class Date {
public:
    // 使用引用避免拷贝，const 保护数据不被修改
    Date(const Date& d) { _year = d._year; _month = d._month; _day = d._day; }
private:
    int _year, _month, _day;
};

浅拷贝与深拷贝

浅拷贝问题

class Stack {
public:
    Stack(int n = 4) {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        _capacity = n;
        _top = 0;
    }
    
    ~Stack() {
        cout << "~Stack()" << endl;
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }
private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

int main() {
    Stack st1;
    st1.Push(1);
    Stack st2(st1); // 浅拷贝，_a 指向同一块内存
    return 0; // 析构时 st1 和 st2 都会 free 同一块内存，程序崩溃
}

深拷贝修正

class Stack {
public:
    Stack(const Stack& st) {
        cout << "Stack(const Stack& st)" << endl;
        _a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
        if (_a == nullptr) {
            perror("malloc fail!!!");
            return;
        }
        memcpy(_a, st._a, sizeof(STDataType) * st._top);
        _top = st._top;
        _capacity = st._capacity;
    }
    // ... 其他成员 ...
};

引用返回与传参优化

传值返回会产生临时对象，效率低。传引用返回可以减少拷贝，但要注意返回对象的生命周期。

// 减少拷贝消耗
Stack& func2() {
    static Stack st; // 静态存储期，函数结束后仍存在
    return st;
}

赋值运算符重载

赋值运算符用于两个已经存在的对象之间拷贝。它与拷贝构造的区别在于：一个是初始化新对象，一个是赋值给旧对象。

特点：

• 必须重载为成员函数。
• 参数建议为 const 当前类类型引用。
• 返回值建议为 当前类类型引用（支持连续赋值 a=b=c）。
• 若实现了析构释放资源，必须实现赋值运算符重载。

class Date {
public:
    Date& operator=(const Date& d) {
        if (this != &d) { // 自赋值检查
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
        return *this; // 支持连续赋值
    }
private:
    int _year, _month, _day;
};

运算符重载

C++ 允许通过运算符重载指定类类型对象的行为。重载后的优先级和结合性与内置类型一致。

规则：

• 一元运算符有一个参数，二元运算符有两个参数。
• 若是成员函数，左侧运算对象由隐式的 this 指针传递。
• << 和 >> 必须重载为全局函数，因为 this 会抢占第一个位置。
• 后置 ++ 需增加一个 int 形参以区分前置 ++。

访问私有成员

全局重载函数无法直接访问私有成员，解决方法有：

1. 成员公开（不推荐）。
2. 提供 Getter 函数。
3. 友元函数。
4. 重载为成员函数。

// 友元方式
class Date {
    friend bool operator==(const Date& d1, const Date& d2);
    // ...
};

bool operator==(const Date& d1, const Date& d2) {
    return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}

实战案例：日期类实现

下面是一个完整的日期类实现，涵盖了构造函数、析构、拷贝、赋值、运算符重载及流操作。

头文件 (Date.h)

#pragma once
#include <assert.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 = 1990, int month = 1, int day = 1) {
        _year = year; _month = month; _day = day;
        if (!CheckDate()) {
            cout << "非法日期";
            Print();
        }
    }

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

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

    bool CheckDate();

    bool operator<(const Date& d);
    bool operator<=(const Date& d);
    bool operator>(const Date& d);
    bool operator>=(const Date& d);
    bool operator==(const Date& d);
    bool operator!=(const Date& d);

    Date& operator+=(int day);
    Date operator+(int day);
    Date& operator-=(int day);
    Date operator-(int day);

    Date operator++(int);
    Date& operator++();
    Date operator--(int);
    Date& operator--();

    int operator-(const Date& d);

private:
    int _year;
    int _month;
    int _day;
};

ostream& operator<<(ostream& out, const Date& d);
istream& operator>>(istream& in, Date& d);

实现文件 (Date.cpp)

#define _CRT_SECURE_NO_WARNINGS
#include "Date.h"

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

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

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

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

bool Date::operator<(const Date& d) {
    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) { return *this < d || *this == d; }
bool Date::operator>(const Date& d) { return !(*this <= d); }
bool Date::operator>=(const Date& d) { return !(*this < d); }
bool Date::operator==(const Date& d) { return _year == d._year && _month == d._month && _day == d._day; }
bool Date::operator!=(const Date& d) { return !(*this == d); }

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--() {
    *this -= 1;
    return *this;
}

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

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

istream& operator>>(istream& in, Date& d) {
    cout << "请输入年月日: >";
    in >> d._year >> d._month >> d._day;
    return in;
}

取地址运算符重载与 Const 成员函数

Const 成员函数

将 const 修饰的成员函数称为 const 成员函数。它修饰的是隐含的 this 指针，表明在该函数内不能修改任何成员变量。

class Date {
public:
    void Print() const {
        cout << _year << "/" << _month << "/" << _day << endl;
    }
};

int main() {
    const Date d1(2025, 11, 30);
    d1.Print(); // const 对象只能调用 const 成员函数
    return 0;
}

取地址运算符重载

分为普通地址运算符和 const 取地址运算符重载。一般编译器生成的足够用，除非有特殊场景（如不想让别人获取对象地址）。

class Date {
public:
    Date* operator&() {
        return this;
    }
    const Date* operator&() const {
        return this;
    }
private:
    int _year, _month, _day;
};