C++赋值运算符重载深度解析：深拷贝、自赋值与五法则

1. 从一次双重释放事故讲起

先把话说在前头：赋值运算符重载，是C++类设计里最容易被轻视、又最容易炸出内存问题的环节。我见过太多写了三五年C++的人，遇到std::string、std::vector用得飞起，但自己手写一个带指针成员的类时，照样在operator=上翻车。最典型的场景就是：类里有一个char*或者int*成员，编译器默认生成的赋值运算符做了逐成员拷贝，两个对象指向同一块堆内存，析构的时候各自delete一次，程序直接崩溃。你查半天才发现，问题压根不在析构函数，而在赋值那一步。

这篇文章要讲的，就是围绕“C++类和对象”中赋值运算符重载的完整细节。我会从默认赋值行为为什么会出问题讲起，一路深入到返回值类型、自我赋值处理、异常安全、移动语义配合，最后给出一个可以直接抄走的完整实现范式。适合的对象是：正在学C++的初学者（尤其是被double free折磨过的人），以及写了好几年C++但没系统梳理过operator=编写规范的从业者。

需要提前说明的是，这篇文章里的所有实现思路都是基于C++11及之后的标准。如果你还在用C++98，部分代码需要微调，我会在对应位置标注。整个阅读过程大概十五分钟，但我建议你打开编译器跟着敲一遍，赋值运算符这东西，光看不练是记不住的。

2. 赋值运算符为什么难写：三条底层逻辑

2.1 默认赋值是“值拷贝”，但指针成员要的是“深拷贝”

编译器会为每个类自动生成赋值运算符，前提是你没有自己声明任何一个operator=版本。它做的事情很简单：对每个非静态成员，逐个调用该成员的赋值运算符。对于int、double这种内置类型，赋值就是直接拷值；但对于指针成员，赋值拷贝的是指针本身——也就是地址。

这就引出第一个核心问题：地址拷贝之后，两个对象的指针成员指向同一块内存。假如类里还有析构函数负责释放这块内存，那么第一个对象析构时把内存释放了，第二个对象析构时再次释放同一块内存——这就是臭名昭著的double free。更隐蔽的是，如果你通过第二个对象修改了指针指向的内容，第一个对象看到的数据也跟着变了，因为本来就是同一块内存，这叫“浅拷贝副作用”。你可以把这种情况类比成：两个人共用一个银行账户，一个人取钱，另一个人余额就少了；一个人注销账户，另一个人手里的卡就成废卡了。

默认赋值运算符不会报错，它只是在你不知道的时候，埋下一颗定时炸弹。等你真正踩到的时候，往往已经离出事点很远了，排查起来极其痛苦。

2.2 拷贝构造与赋值运算符的“分工差异”

很多人把拷贝构造函数和赋值运算符混在一起记，觉得都是“把一个对象复制给另一个对象”，但它们的触发时机完全不同：

• 拷贝构造：创建一个新对象时，用已有对象初始化它。
• 赋值运算符：两个对象都已存在，把右侧对象的值赋给左侧对象。

代码上区分的话：

cpp复制MyClass a(10);
MyClass b = a;   // 拷贝构造，因为 b 是刚创建的
MyClass c;
c = a;           // 赋值运算符，因为 c 已经存在了

这里有个常见坑：MyClass b = a;看起来像赋值，实际上走的是拷贝构造。如果你在拷贝构造里写了正确的深拷贝，但赋值运算符没重写，依然会踩浅拷贝的坑。所以写类的时候，拷贝构造和赋值运算符必须成对考虑，只修一个不够。这也是后面要讲的“三法则”和“五法则”存在的意义。

2.3 三法则：什么时候必须自己写赋值运算符

所谓“三法则”，指的是：**如果类需要自定义析构函数、拷贝构造函数或拷贝赋值运算符中的任何一个，那么通常三个都需要自定义。**理由是这三个成员函数处理的都是同一个东西——资源的获取与释放。只要类里有堆内存、文件句柄、互斥锁、数据库连接等资源，默认的逐成员拷贝几乎必然出错。

举个例子，一个类只有int成员，析构函数什么都不用做，那拷贝构造和赋值运算符也用不着自己写。但一旦加了int*成员、并且析构函数里需要delete，三法则就生效了。判断标准很简单：**你的复制操作是要“共享资源”还是“独立拥有资源”？**独立拥有就得自己写深拷贝。这个判断一定要养成条件反射，面试里问三法则、算法题里写链表类，都靠它。

C++11之后，三法则升级成了五法则——多了移动构造函数和移动赋值运算符。我后面单独讲，先说清楚基础的复制版本。

3. 赋值运算符重载的完整实现与逐步拆解

3.1 标准签名：为什么返回值必须是引用

规范的赋值运算符声明长这样：

cpp复制class MyClass
{
public:
    MyClass& operator=(const MyClass& other);
};

有四个细节需要说清楚：

• 返回类型是MyClass&：为了支持链式赋值，比如a = b = c;。b = c返回b的引用，然后a = b的引用才能继续赋值。如果返回void，链式赋值直接编译报错。如果返回对象本身（也就是MyClass而不是MyClass&），每赋值一次就多一次临时对象的拷贝构造和析构，性能白白损耗。所以返回引用是最优解，既能链式，又不产生额外临时对象。

• 参数是const MyClass&：传引用避免调用时的拷贝开销；加const保证只读，防止函数体内误改源对象。你可能会问：为什么不能用值传递？operator=(MyClass other)这种写法其实也能工作，而且配合移动语义有奇效，但它会强制多一次拷贝或移动构造的调用，性能不如引用传递。后面讲“copy-and-swap”时会提到这种替代方案的权衡。

• 参数名字叫other：这是惯例，表示“另一个对象”，避免和this混淆。

• 必须是成员函数：赋值运算符不能是友元函数或全局函数。这是C++的硬性规定，因为赋值运算符跟“左操作数必须是类对象”绑定在一起，编译器要求它作为成员函数存在。

3.2 实现步骤与核心代码

不绕弯子，直接给出最经典的实现版本：

cpp复制class MyClass
{
public:
    MyClass(int size) : m_size(size), m_data(new int[size])
    {
        for (int i = 0; i < m_size; ++i)
        {
            m_data[i] = i;
        }
    }

    ~MyClass()
    {
        delete[] m_data;
    }

    // 拷贝构造函数
    MyClass(const MyClass& other)
        : m_size(other.m_size), m_data(new int[other.m_size])
    {
        std::copy(other.m_data, other.m_data + other.m_size, m_data);
    }

    // 拷贝赋值运算符
    MyClass& operator=(const MyClass& other)
    {
        if (this == &other)  // 检查自我赋值
        {
            return *this;
        }

        // 先分配新内存，再释放旧内存
        int* newData = new int[other.m_size];
        std::copy(other.m_data, other.m_data + other.m_size, newData);

        delete[] m_data;

        m_size = other.m_size;
        m_data = newData;

        return *this;
    }

private:
    int m_size;
    int* m_data;
};

这段代码里每一行都不是废话，我按执行顺序拆给你看：

第一步，自我赋值检查。if (this == &other)的意思是：判断两个对象的地址是否相同，也就是是不是同一个对象。如果不做这个检查，delete[] m_data会把自身的堆内存释放掉，紧接着new int[other.m_size]去读取已经被释放的内存，属于未定义行为，轻则数据错乱，重则崩溃。这种错误在a = a;这种代码里看着很蠢，但实际工程里，经常通过别名的形式发生——两个引用或指针指向同一个对象，代码路径一绕，就触发了自我赋值。所以这个检查必须写，而且必须写在所有操作之前。

第二步，先分配新内存，再拷贝数据，最后释放旧内存。这个顺序极其重要。很多人上来就写delete[] m_data; m_data = new int[other.m_size];，这样如果new抛出异常（比如内存不足），对象已经处于半毁状态：旧数据没了，新数据没来，类不变量被打破。先分配再释放的好处是，如果new失败，异常抛出时对象还保有完整的旧数据，不会进入非法状态。这就是“强异常安全保证”的雏形。

第三步，更新成员变量。注意顺序是m_size = other.m_size; m_data = newData;，先改大小再换指针，避免中途出现大小和指针不匹配的情况。

3.3 自赋值检查的边界情况

自赋值检查看着简单，但有几个边界情况值得多说一句。

第一种是当两个对象内容相同但地址不同，比如：

cpp复制MyClass a(10);
MyClass b(a);
a = b;  // 内容相同，但 this != &b，不需要自赋值检查

这种场景下，即使不做自赋值检查，整个流程也能正确完成，最多是白白做了一次拷贝。所以自赋值检查在功能上不是必需的，它更像一个性能优化和防御性编程手段。

第二种情况是继承体系下的自赋值，基础类指针指向派生类对象，再通过基类引用赋给另一个基类引用，地址相同但静态类型不同。这种比较this == &other依然可靠，因为地址就是对象在内存中的真实位置。

第三种情况是多线程下两个线程同时给同一个对象赋值——抱歉，这种情况自赋值检查救不了你，赋值运算符本来就不保证线程安全。你需要的是外部加锁。

网上有些教程说自赋值检查可以省略，因为用“copy-and-swap”写法天然免疫自赋值。这话没错，但那是在你用了更高阶写法的前提下。对于新手来说，我把自赋值检查教成“肌肉记忆”——就算你以后改用copy-and-swap，多写这一个判断也不影响正确性，而且还能省下不少无效拷贝开销。

4. 进阶写法：copy-and-swap的优雅与代价

4.1 什么是copy-and-swap

经典写法有自赋值检查、手工管理new/delete、异常安全分段设计，逻辑严密，但要写的代码比较多。另一种广为流传的写法叫“copy-and-swap”，代码更短、异常安全性更强，很多C++老手偏爱它。

核心思路是把赋值分成两步：

1. 用拷贝构造函数创建一个临时对象，此时如果拷贝失败（比如new抛异常），什么都不用管，原有对象没被改动。
2. 把临时对象和this指向的对象交换，临时对象在函数结束时会析构，把旧资源带走释放。

代码长这样：

cpp复制class MyClass
{
public:
    MyClass(int size) : m_size(size), m_data(new int[size]) {}

    ~MyClass()
    {
        delete[] m_data;
    }

    MyClass(const MyClass& other)
        : m_size(other.m_size), m_data(new int[other.m_size])
    {
        std::copy(other.m_data, other.m_data + other.m_size, m_data);
    }

    // 交换函数，必须是非静态成员或友元
    void swap(MyClass& other) noexcept
    {
        using std::swap;
        swap(m_size, other.m_size);
        swap(m_data, other.m_data);
    }

    // 传值方式接收参数
    MyClass& operator=(MyClass other)
    {
        swap(other);
        return *this;
    }
};

注意这里赋值运算符的参数改成了值传递MyClass other，不是引用。这意味着传参过程中会调用一次拷贝构造函数，在other里生成当前对象的深拷贝副本。然后swap(other)把新增的副本和当前对象交换，函数结束时other析构，带走原本属于this的旧数据。

4.2 为什么它会自动免疫自赋值和异常

自赋值场景下，a = a时，other通过拷贝构造成为a的独立副本，然后swap，最后other析构。整个过程没有自我释放再读取的未定义行为，天然安全。异常安全方面，拷贝构造抛异常时函数直接退出，当前对象没被动过，这比经典写法更强——经典写法只保证异常发生时对象处于合法状态，不保证数据和原来一致；而copy-and-swap保证的是对象完全不变，这叫“强异常安全保证”。

4.3 copy-and-swap的代价与适用场景

但天下没有免费的午餐。值传参意味着每次赋值都会多一次拷贝构造调用。如果你赋值操作非常频繁，或者对象拷贝本身很重（比如有几百万个元素的vector成员），性能开销会明显放大。经典写法直接构造新资源再释放旧资源，节省了临时对象这一步的构造和析构。

我在实际项目里的习惯是：

• 类比较小、数量不多，或者赋值频率很低时，优先用copy-and-swap，省心，不容易写错。
• 类很大、赋值很频繁（比如作为容器元素被反复赋值），用经典写法，配合自赋值检查和分段异常安全逻辑。

另外一个需要注意的点是：copy-and-swap里的swap函数建议声明为noexcept——因为swap操作本质上只是交换两个指针和两个整数，不会分配内存、不会抛出异常。声明noexcept后，编译器在某些容器（比如std::vector的重新分配）里会更愿意使用移动语义而不是拷贝，这是C++11之后的重要优化点。

5. 移动赋值运算符：C++11之后必须补的一环

5.1 什么时候需要移动赋值

先把结论放了：如果你的类自定义了析构函数，那么请同时实现移动构造函数和移动赋值运算符，否则你会白白丢失很多性能。

移动赋值的触发场景是：右侧操作数是一个右值（临时对象或std::move的产物）。比如a = std::move(b);或者a = MyClass(10);这种方式，编译器会优先匹配移动赋值运算符。如果没有移动赋值运算符，就会退化为拷贝赋值——功能没问题，但多了一次没有必要的深拷贝。对持有大块内存或资源的类来说，这种退化可能在性能上差出几个数量级。

还是拿std::string来类比：字符串连接str1 = str2 + str3;右侧是临时string，如果走拷贝赋值，需要完整复制一遍完整的字符串内容；如果走移动赋值，直接把临时对象内部的堆内存指针“偷”过来，再把临时对象的指针置空。相当于搬家时直接把一整个衣柜搬走，而不是一件一件拿出来再放进新家。

5.2 移动赋值运算符的实现范式

一个规范的移动赋值运算符写法：

cpp复制MyClass& operator=(MyClass&& other) noexcept
{
    if (this == &other)  // 自我移动赋值也需要检查
    {
        return *this;
    }

    delete[] m_data;   // 释放当前对象占有的资源

    m_size = other.m_size;   // 接管 other 的资源
    m_data = other.m_data;

    other.m_size = 0;        // 将 other 置于有效但未定义的空状态
    other.m_data = nullptr;

    return *this;
}

关键点有两个：

• 必须把源对象置为“空”状态。因为other是右值，之后会被析构。如果移动后other.m_data还指着那块堆内存，析构时就会和this双重释放。标准C++只要求“移后源对象处于有效但未指定状态”，实际操作中我习惯把指针置空、大小归零，这样即使有人误用了移后源对象，最多是空指针或空容器，不会产生内存安全问题。

• 声明noexcept。这是性能关键点。std::vector扩容时，如果元素的移动构造函数/移动赋值运算符没有标记noexcept，编译器可能不会用移动而选择用拷贝，因为拷贝是绝对安全的（保证不抛异常），而移动若抛异常会破坏vector的强异常安全保证。所以，移动操作不抛异常，就务必声明noexcept，这是一条硬规则。

5.3 移动赋值和拷贝赋值的重载选择机制

两个版本同时存在时，编译器根据实参类型选择：

• a = b; → operator=(const MyClass&) → 拷贝赋值
• a = std::move(b); → operator=(MyClass&&) → 移动赋值
• a = MyClass(10); → operator=(MyClass&&) → 移动赋值（临时对象是右值）

这个重载机制和普通函数重载完全一致，没有特殊规则。所以你想给类加移动语义，直接声明第二个重载就行，不需要任何关键字或开关。

有一点要提醒：移动赋值和移动构造都实现之后，五法则才算完整。完整的五成员函数是：析构函数、拷贝构造函数、拷贝赋值运算符、移动构造函数、移动赋值运算符。如果你只实现了拷贝版本，C++11之后编译器不会隐式生成移动版本；如果你只实现了移动版本，拷贝版本会被“删除”（= delete）。这其中的规则比较复杂，我的建议是：**一旦你的类需要自定义析构，就把五个全写上，或者用= default显式声明你确定不需要自定义的版本。**宁可多写，不要依赖编译器猜测你的意图。

6. 工程实战中的常见坑与排查技巧

6.1 典型编译错误：表达式必须包含类类型

这是我在新手区看到最多的编译错误之一。报错信息“表达式必须包含类类型”通常出现在类似下面的代码里：

cpp复制MyClass a(10);
MyClass b(20);
a.operator=(b);  // 这样写没问题但很少见
a = b;           // 如果提示"表达式必须包含类类型"，说明 a 被声明成了指针

排查方向很明确：a是一个指针而不是对象。比如：

cpp复制MyClass* a = new MyClass(10);
MyClass b(20);
a = b;  // 编译错误：MyClass* 不能赋值给 MyClass*？

上面这个a = b实际是尝试把MyClass对象赋给MyClass*指针，类型不匹配导致报错。正确写法是*a = b;。如果你把赋值运算符调用写成了a.operator=(b)，而a是指针，应该写作a->operator=(b)或者直接*a = b;。

这个错误本质是类型层面的问题，不是重载本身的问题，但高频出现，我在团队带新人时经常在code review里看到。如果你被这个报错卡住，先检查变量声明旁边有没有星号。

6.2 运行时崩溃：double free的排查思路

double free的报错一般长这样：

text复制*** Error in `./a.out': double free or corruption (fasttop): 0x00000000016a5c20 ***

遇到这种问题，我建议按以下顺序排查：

1. 先看类里有没有自定义析构函数，会不会释放堆内存。
2. 再看有没有自写拷贝构造函数和赋值运算符。如果没写，立即怀疑浅拷贝。
3. 如果有自写但还崩，检查拷贝构造和赋值运算符里是不是都做了深拷贝——有人只写了赋值运算符，忘了拷贝构造；也有人只写了拷贝构造，忘了赋值运算符。
4. 检查移动赋值里是不是忘了把源对象的指针置空。
5. 戴上-fsanitize=address重新编译运行，AddressSanitizer会直接告诉你哪一行释放了已经被释放的内存。

我用地址消毒器（AddressSanitizer）排查过太多次内存问题，几乎每次都能精确定位到行号，强烈建议所有C++开发者至少会用-fsanitize=address编译选项。

6.3 隐蔽错误：赋值后修改源对象影响了目标对象

这种错误不崩溃，但数据错乱，比崩溃更难排查。场景如下：你写了一个类，成员里有个std::vector<int>，但出于“性能考虑”用int*和size自己管理内存。如果你没重写赋值运算符，默认赋值只拷贝指针和size。然后执行：

cpp复制MyClass a;
MyClass b;
b = a;
a.data()[0] = 100;  // 你以为只改了 a，但 b 的第一个元素也跟着变了

因为a和b共享同一个底层数组。这种错误在业务代码里极难追踪，因为问题现象和赋值语句的关系不明显。我的排查经验是：当两个对象的数据总是同步变化、而不是各自独立时，直接怀疑浅拷贝。解决办法就是本文前面写的深拷贝赋值运算符。

更激进一点：如果你的类暴露了返回内部指针的接口（比如int* data()），不管你怎么深拷贝，外部都可能通过这个指针拿到内部资源。工程上我建议要么不暴露裸指针，要么用const限定让外部只能只读访问。真需要修改时走类提供的修改方法，让类自己控制数据一致性。

6.4 默认赋值、浅拷贝与容器操作的关系

还有一个隐蔽场景值得单独拿出来讲：把对象放进std::vector时的扩容行为。比如：

cpp复制std::vector<MyClass> vec;
vec.push_back(MyClass(10));  // 临时对象

push_back之后的扩容，vector可能要搬运已有元素。C++11之前，它只能拷贝构造新位置然后销毁旧位置；C++11之后，如果MyClass有noexcept的移动构造，就用移动；如果没有，兜底还是拷贝构造。如果你的拷贝构造没写深拷贝，vector扩容后一半元素共享同一块堆内存——程序跑着跑着就崩溃，而且崩溃位置可能在vector完全无关的地方，排查难上加难。

所以我在项目里的硬性规范是：**所有放进容器的自定义类型，要么是平凡可拷贝的，要么必须完整实现五法则。**代码审查时看到“自定义析构 + 未自定义拷贝/移动”的组合，一律打回。

7. 赋值运算符重载后的扩展思考

写到这里，关于赋值运算符重载的核心内容基本覆盖完了。文章开头提过“后续扩展”，我想了两个方向和读者分享，算是给已经在工作中遇到实际问题的人一些参考。

第一个方向是赋值运算符和标准库容器的协作。如果你用的是std::shared_ptr来管理资源，赋值运算符可以交给编译器默认生成——shared_ptr的拷贝赋值会正确增加引用计数，不需要你手工写深拷贝。这是现代C++里非常推荐的资源管理方式，能省掉大量手写运算符的麻烦。但要注意，这并不代表你可以完全不理解浅拷贝深拷贝的机制——你只是把这个问题交给了标准库去处理，而不是在语言层面消除了它。面试时候被问到原理，依然要能把指针成员、堆内存管理这些底层逻辑讲清楚。

第二个方向是链表、树等递归结构中的赋值语义。这类结构的特点是嵌套指针：每个节点里可能还有指向子节点的指针。赋值时要递归深拷贝整棵结构，释放时要递归删除全部节点。此时直接套用本文的线性数组写法是不够的，需要把copy和swap设计成递归版本。实现不难，但容易在递归边界上出错，建议配合单元测试覆盖空结构、单节点、深层链、自引用（有环时无解）等边界情况。

第三个方向是返回*this这个约定的来源。a = b = c为什么能工作？因为赋值运算符是右结合的，b = c先执行，返回b的引用，然后a = b的引用再执行。这个约定从C语言的内置类型赋值就继承了：内置类型的赋值结果是一个左值引用，程序员习惯了链式赋值，所以类的赋值运算符也要遵循同样的约定，否则写a = b = c的代码在类对象上编译报错，使用者会一脸懵。语言设计者把“赋值运算要对标内置类型行为”作为默认约定，我们实现类时也应当如此。

8. 最后的经验之谈：写赋值运算符前先把五法则背熟

我在讲到最后，还是想说实话：赋值运算符重载这一块，光看文章是不可能完全掌握的。我当年第一次写带指针的类，自以为拷贝构造、赋值、析构都写了，结果把对象塞进std::vector，运行了十分钟才崩溃，查了一晚上才发现是移动构造函数没写，vector扩容时走了拷贝路径，而拷贝构造里的深拷贝写得有问题——std::copy的参数写反了，越界写坏了堆内存。那次之后我养成一个习惯：任何自定义析构函数的类，写完第一件事就是把这五个成员函数列出来，能= default就= default，该手写就手写，一个不落。

最后分享一个检查心法：当你写完赋值运算符，问自己三个问题——**它处理自我赋值吗？它异常安全吗？它和拷贝构造、析构函数的行为一致吗？**如果三个答案都是肯定的，这个运算符基本可以放心上线。如果任何一个答不上来，别急着提交，打开编译器，写几行测试代码验证一下，成本比上线后让运维半夜叫醒你低得多。

这篇文章到此收尾。赋值运算符重载是C++里少有的、把语法、内存、设计、性能四个维度同时压在一段代码上的知识点，值得花时间死磕。你愿意看到这里，大概率已经是在认真对待这门语言的人了，把文中代码亲手跑一遍，踩一踩那些坑，它会成为你C++道路上很扎实的一块基石。