C++赋值运算符重载的正确实现方法详解

昨天 4986阅读

在C++面向对象编程中，当类管理动态资源（如堆内存、文件句柄等）时，必须显式定义赋值运算符重载函数。否则，编译器生成的默认赋值操作仅执行浅拷贝，可能导致双重释放、内存泄漏或数据竞争等严重问题。本文将深入讲解如何安全、高效地实现赋值运算符重载。

为什么需要自定义赋值运算符？

默认的赋值运算符会逐成员复制对象内容。若类中包含指针成员，这种浅拷贝会使多个对象共享同一块内存。一旦任一对象析构，其他对象的指针将变为悬空指针，后续访问将引发未定义行为。

class BadExample {
public:
    int* data;
    BadExample(int value) {
        data = new int(value);
    }
    // 缺少自定义赋值运算符 → 危险！
    ~BadExample() {
        delete data;
    }
};

上述代码在执行 obj1 = obj2; 后，两个对象的 data 指向同一地址，析构时将导致重复释放。

C++赋值运算符重载的正确实现方法详解

实现赋值运算符的关键步骤

一个健壮的赋值运算符应遵循以下原则：

检查自赋值：避免对象给自己赋值时误删自身资源。
释放当前资源：先清理已有资源，防止内存泄漏。
深拷贝新资源：从源对象复制一份独立的数据。
返回自身引用：支持连续赋值（如 a = b = c）。

基础实现示例

class SafeString {
private:
    char* buffer;
    size_t len;

public:
    // 构造函数
    SafeString(const char* str = "") {
        len = strlen(str);
        buffer = new char[len + 1];
        strcpy(buffer, str);
    }

    // 拷贝构造函数（通常与赋值运算符一同实现）
    SafeString(const SafeString& other) {
        len = other.len;
        buffer = new char[len + 1];
        strcpy(buffer, other.buffer);
    }

    // 赋值运算符重载
    SafeString& operator=(const SafeString& other) {
        // 1. 自赋值检查
        if (this == &other) {
            return *this;
        }

        // 2. 释放当前资源
        delete[] buffer;

        // 3. 深拷贝
        len = other.len;
        buffer = new char[len + 1];
        strcpy(buffer, other.buffer);

        // 4. 返回自身引用
        return *this;
    }

    // 析构函数
    ~SafeString() {
        delete[] buffer;
    }
};

更安全的现代写法：复制-交换（Copy-and-Swap）

为避免异常安全性问题（如 new 抛出异常导致对象处于无效状态），推荐使用“复制-交换”惯用法。该方法利用临时对象和 swap 函数，确保强异常安全保证。

#include <algorithm> // for std::swap

class ModernString {
private:
    char* buffer;
    size_t len;

    // 辅助函数：交换两个对象的内容
    void swap(ModernString& other) noexcept {
        std::swap(buffer, other.buffer);
        std::swap(len, other.len);
    }

public:
    ModernString(const char* str = "") {
        len = strlen(str);
        buffer = new char[len + 1];
        strcpy(buffer, str);
    }

    // 拷贝构造函数
    ModernString(const ModernString& other) {
        len = other.len;
        buffer = new char[len + 1];
        strcpy(buffer, other.buffer);
    }

    // 赋值运算符：采用复制-交换
    ModernString& operator=(ModernString other) {
        // 注意：参数按值传递，自动调用拷贝构造
        swap(other); // 交换当前对象与临时副本
        // other 离开作用域时自动析构原资源
        return *this;
    }

    ~ModernString() {
        delete[] buffer;
    }
};

此方法优势在于：