C++ 类和对象：拷贝构造与赋值运算符详解

实战示例：栈的深浅拷贝

以栈（Stack）为例，观察浅拷贝的后果与深拷贝的实现。

浅拷贝的风险

typedef int STDataType;
class Stack {
public:
    Stack(int n = 4) {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (_a == nullptr) {
            perror("malloc 申请空间失败");
            return;
        }
        _capacity = n;
        _top = 0;
    }

    // 浅拷贝：仅拷贝指针地址
    Stack(const Stack& s) {
        _a = s._a;
        _capacity = s._capacity;
        _top = s._top;
    }

    ~Stack() {
        cout << "~Stack()" << endl;
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }

private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

int main() {
    Stack s1;
    s1.Push(1);
    Stack s2(s1); // 浅拷贝
    return 0;
}

上述代码中，s1 和 s2 的 _a 指向同一块堆内存。当 s2 析构释放内存后，s1 再析构时会再次释放同一块内存，导致程序崩溃。

深拷贝实现

Stack(const Stack& s) {
    _a = (STDataType*)malloc(sizeof(STDataType) * s._capacity);
    if (_a == nullptr) {
        perror("realloc fail");
        return;
    }
    memcpy(_a, s._a, s._top * sizeof(STDataType));
    _capacity = s._capacity;
    _top = s._top;
}

通过重新分配内存并复制数据，确保两个对象拥有独立的存储空间。

赋值运算符重载

赋值运算符重载用于完成两个已存在对象之间的拷贝复制，需与拷贝构造区分开。

运算符重载基础

1. 成员函数特性：作为成员函数时，左侧运算对象由隐式的 this 指针提供，参数少一个。
2. 全局函数需求：对于 << 和 >> 这类运算符，通常需重载为全局函数，以便将流对象放在第一个参数位置。
3. 限制：不能改变内置类型含义，不能创建新符号，部分运算符（如 .*, ::, sizeof, ? :, .）不可重载。

赋值运算符核心要点

1. 成员函数：C++ 规定必须为成员函数。
2. 参数建议：使用 const 当前类类型引用传参，避免拷贝开销。
3. 返回值：建议返回当前类类型引用（Date&），支持连续赋值（如 d1 = d2 = d3）。
4. 自赋值检查：必须检查 this != &other，防止自我赋值导致逻辑错误或资源丢失。
5. 深浅拷贝：与拷贝构造类似，涉及动态资源的类需要自定义深拷贝。

代码示例

#include <iostream>
using namespace std;

class Date {
public:
    Date(int day = 8, int month = 1, int year = 2026) {
        _day = day;
        _month = month;
        _year = year;
    }

    // 拷贝构造
    Date(const Date& d) {
        _day = d._day;
        _month = d._month;
        _year = d._year;
    }

    // 赋值重载
    Date& operator=(const Date& d) {
        if (this != &d) { // 自赋值检查
            _day = d._day;
            _month = d._month;
            _year = d._year;
        }
        return *this; // 返回自身引用，支持链式赋值
    }

    void Print() {
        cout << _year << '/' << _month << '/' << _day << endl;
    }

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

int main() {
    Date d1(1, 1, 1);
    Date d2(d1);      // 拷贝构造
    Date d3 = d1;     // 拷贝构造
    d2.Print();
    d3.Print();

    Date d4;
    Date d5;
    d5 = d4 = d1;     // 赋值重载，支持链式
    d4.Print();
    return 0;
}

总结

拷贝构造函数与赋值运算符重载构成了 C++ 对象复制机制的核心支柱。它们分别负责对象初始化和对象赋值两种不同场景的复制需求。

掌握这些复制控制机制，不仅能写出更安全的代码，更能深入理解 C++ 对象生命周期的管理哲学。这是从 C++ 使用者迈向 C++ 设计者的重要一步。