C++ 类和对象进阶：构造、析构与运算符重载

特殊场景：容器中的对象

当类中包含其他自定义类型成员时，构造顺序很重要。编译器会先调用成员的构造函数，再执行当前类的构造函数体。

typedef int STDataType;

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

class MyQueue {
public:
    // 编译器默认生成 MyQueue 的构造函数，调用了 Stack 的构造
    // 完成了两个成员的初始化
private:
    Stack pushst;
    Stack popst;
};

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

析构函数

析构函数与构造函数功能相反，用于对象生命周期结束时清理资源。C++ 规定对象销毁时会自动调用析构函数。

关键特性：

• 函数名是类名前加 ~，如 ~Stack()。
• 无参数、无返回值。
• 一个类只能有一个析构函数。
• 若未显式定义，系统生成默认析构函数。
• 对象生命周期结束（如离开作用域）时自动调用。

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

运用示例

typedef int STDataType;

class Stack {
public:
    Stack(int n = 4) {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (nullptr == _a) {
            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 {
private:
    // 自定义类型成员，析构时会递归调用 Stack 的析构
    Stack pushst;
    Stack popst;
};

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

拷贝构造函数

如果一个构造函数的第一个参数是自身类类型的引用，且额外参数都有默认值，则称为拷贝构造函数。它是构造函数的重载形式。

核心规则：

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

何时需要自己实现？

1. 像 Date 这样全是内置类型且无资源，默认即可。
2. 像 Stack 这样有指针指向堆资源，默认浅拷贝会导致析构时重复释放，需实现深拷贝。
3. 像 MyQueue 内部是自定义类型，默认会调用成员的拷贝构造，通常无需重写。

经验法则： 如果类显式实现了析构并释放资源，那么通常需要显式实现拷贝构造和赋值运算符。

常见误区：无穷递归

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

void Func1(const Date& d) {
    cout << &d << endl;
    d.Print();
}

int main() {
    Date d1(2025, 11, 16);
    d1.Print();
    Func1(d1);
    Date d2(d1); // 调用拷贝构造
    d2.Print();
    return 0;
}

浅拷贝与深拷贝

问题：同一空间被释放两次

#include<iostream>
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;
    }

    void Push(STDataType x) {
        if (_top == _capacity) {
            int newCapacity = _capacity * 2;
            STDataType* tmp = (STDataType*)realloc(_a, newCapacity * sizeof(STDataType));
            if (tmp == NULL) {
                perror("realloc fail");
                return;
            }
            _a = tmp;
            _capacity = newCapacity;
        }
        _a[_top++] = x;
    }

    ~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);
    st1.Push(2);
    
    // 未实现拷贝构造，默认浅拷贝
    // st1 和 st2 的 _a 指向同一块内存，析构时 crash
    Stack st2(st1);
    return 0;
}

解决：深拷贝

// 在 Stack 类中添加拷贝构造
Stack(const Stack& st) {
    cout << "Stack(const Stack& st)" << endl;
    _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;
}

引用返回与效率优化

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

// 减少拷贝消耗
Stack& func2() {
    static Stack st; // 静态存储期，避免返回局部对象野引用
    return st;
}

int main() {
    Stack ret = func2();
    return 0;
}

赋值运算符重载

赋值运算符用于两个已存在对象之间的赋值，区别于拷贝构造（初始化新对象）。

特点：

• 必须重载为成员函数。
• 参数建议为 const 当前类类型引用。
• 返回值建议为 当前类类型引用，以支持连续赋值（如 a = b = 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& operator=(const Date& d) {
        _year = d._year;
        _month = d._month;
        _day = d._day;
        return *this; // 支持连续赋值
    }

    void Print() {
        cout << _year << "/" << _month << "/" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main() {
    Date d1(2025, 11, 26);
    Date d2(2025, 11, 27);
    
    d1 = d2;      // 调用赋值运算符
    Date d3 = d2; // 调用拷贝构造
    
    return 0;
}

运算符重载

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

比较运算符

比较运算符通常重载为成员函数，this 指针指向左侧对象。

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

IO 流重载

<< 和 >> 重载为全局函数，因为左侧运算对象通常是 ostream/istream，无法作为成员函数的 this。

friend ostream& operator<<(ostream& out, const Date& d) {
    out << d._year << "/" << d._month << "/" << d._day;
    return out;
}

friend istream& operator>>(istream& in, Date& d) {
    in >> d._year >> d._month >> d._day;
    return in;
}

前置与后置 ++/--

后置重载需要一个 int 形参来区分。

Date operator++(int) { // 后置
    Date tmp = *this;
    *this += 1;
    return tmp;
}

Date& operator++() { // 前置
    *this += 1;
    return *this;
}

日期类完整实现

下面是一个综合了上述知识点的 Date 类实现，包含日期校验、加减运算及比较。

头文件 (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;
}

测试用例

#define _CRT_SECURE_NO_WARNINGS
#include "Date.h"

void Test01() {
    Date d1(2025, 11, 28);
    d1.Print();
    Date d2 = d1 - 100;
    d2.Print();
}

void Test02() {
    Date d1(2024, 7, 13);
    Date ret1 = d1++;
    ret1.Print();
    d1.Print();
    Date d2(2024, 7, 13);
    Date ret2 = ++d2;
    ret2.Print();
    d2.Print();
}

int main() {
    Test01();
    Test02();
    return 0;
}

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

const 成员函数

在成员函数参数列表后加 const，修饰隐含的 this 指针，表明函数内不修改成员变量。这允许在 const 对象上调用该函数。

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

void Test() {
    const Date d1(2025, 11, 30);
    d1.Print(); // 合法
}

取地址运算符重载

一般不需要显式实现，编译器生成的足够用。但在特殊场景（如单例模式或禁止取址）下可自定义。

class Date {
public:
    Date* operator&() {
        return this;
    }
    const Date* operator&() const {
        return this;
    }
};