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

实际开发中，我们通常需要自己实现构造函数。只有在少数情况下，例如类的成员都是自定义类型且这些类型有合适的默认构造函数时（如用两个 Stack 实现队列），编译器自动生成的构造函数才足够使用。

析构函数

析构函数的职责并非销毁对象本身（对象生命周期结束时会自动销毁），而是清理对象占用的资源，类似于之前实现的 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 (nullptr == _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 (nullptr == _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 修饰的成员函数，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; // 日
};