异常教程

C++ 赋值运算符重载（超详细）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

前言

在 C++ 程序设计中，赋值运算符重载是一个核心概念，它允许开发者自定义对象间的赋值行为。当程序员创建自定义类时，默认的赋值运算符（=）可能无法满足需求，例如处理动态内存管理或资源共享场景。本文将通过循序渐进的方式，结合实例和代码，讲解如何正确实现和理解赋值运算符的重载，帮助开发者避免内存泄漏、逻辑错误等问题。

赋值运算符的作用与默认行为

基础概念

赋值运算符（=）在 C++ 中的作用是将一个对象的值赋给另一个对象。例如：

int a = 5;  
int b = a; // 默认赋值：复制 a 的值给 b

对于用户自定义的类，默认的赋值运算符会执行浅拷贝（shallow copy），即直接复制对象的成员变量。例如：

class MyString {  
public:  
    char* data;  
    MyString(const char* str) {  
        data = new char[strlen(str) + 1];  
        strcpy(data, str);  
    }  
};  

MyString s1("Hello");  
MyString s2("World");  
s2 = s1; // 默认赋值：s2.data 指向 s1.data 的内存地址

此时，s2.data 和 s1.data 指向同一块内存，若后续释放内存，会导致双释放（double free）的内存错误。

为什么需要重载赋值运算符？

默认的赋值运算符在以下场景中存在风险：

  1. 动态资源管理：如动态分配的内存、文件句柄等，浅拷贝可能导致资源竞争或泄漏。
  2. 对象状态一致性：某些类需要确保赋值后对象的状态符合特定规则（例如智能指针的引用计数）。
  3. 自定义逻辑：例如，需要赋值时执行特殊操作（如日志记录或资源回收）。

赋值运算符重载的语法与实现

基本语法

赋值运算符重载的函数原型如下：

ClassName& operator=(const ClassName& other);

关键点：

  • 返回类型：必须返回一个引用（ClassName&），以便支持链式赋值（如 a = b = c）。
  • 参数：通常接受一个常量引用（const ClassName& other），避免不必要的对象拷贝。

实现步骤

以 MyString 类为例，实现赋值运算符重载的步骤如下：

  1. 自赋值检查：防止 a = a 时发生错误。
  2. 释放旧资源：释放当前对象已占用的内存。
  3. 复制新资源：从 other 对象中复制数据。
  4. 返回当前对象引用：支持链式赋值。

代码示例：

class MyString {  
public:  
    char* data;  
    MyString(const char* str);  
    ~MyString() { delete[] data; } // 析构函数  
    MyString& operator=(const MyString& other); // 赋值运算符声明  
};  

MyString& MyString::operator=(const MyString& other) {  
    if (this == &other) { // 自赋值检查  
        return *this;  
    }  

    delete[] data; // 释放旧资源  

    data = new char[strlen(other.data) + 1]; // 复制新资源  
    strcpy(data, other.data);  

    return *this; // 返回当前对象引用  
}

深拷贝与浅拷贝的区别

  • 浅拷贝：直接复制指针或引用，两个对象指向同一块内存。
  • 深拷贝：复制指针所指向的数据，确保两个对象独立。

在上述代码中，通过 delete[] 和 new 实现了深拷贝，避免了内存泄漏问题。

赋值运算符与拷贝构造函数的关系

共同点与差异

  • 共同点：两者均涉及对象的复制，且默认行为均为浅拷贝。
  • 差异：
    • 拷贝构造函数：在创建新对象时调用（如 MyString s2 = s1;）。
    • 赋值运算符：在已有对象间进行赋值（如 s2 = s1;）。

协同工作示例

MyString s1("Hello");  
MyString s2; // 默认构造  
s2 = s1; // 调用赋值运算符  
MyString s3 = s1; // 调用拷贝构造函数

实际案例与代码分析

案例 1：动态数组的深拷贝

假设有一个 IntArray 类，管理动态数组：

class IntArray {  
public:  
    int* data;  
    int size;  
    IntArray(int sz) : size(sz) { data = new int[size]; }  
    ~IntArray() { delete[] data; }  
    IntArray& operator=(const IntArray& other);  
};  

IntArray& IntArray::operator=(const IntArray& other) {  
    if (this == &other) {  
        return *this;  
    }  

    delete[] data; // 释放旧内存  

    size = other.size;  
    data = new int[size];  
    memcpy(data, other.data, size * sizeof(int));  

    return *this;  
}

此代码通过深拷贝确保两个对象的内存独立。

案例 2：资源竞争问题

若未重载赋值运算符，可能导致资源竞争：

class FileHandler {  
public:  
    FILE* file;  
    FileHandler(const char* filename) { file = fopen(filename, "r"); }  
    ~FileHandler() { fclose(file); }  
    // 未重载赋值运算符  
};  

FileHandler fh1("data.txt");  
FileHandler fh2;  
fh2 = fh1; // 默认赋值：fh2.file 指向 fh1.file  
// 当 fh1 和 fh2 都调用 fclose，导致崩溃

通过重载赋值运算符实现深拷贝（如复制文件内容到新内存），可避免此类问题。

注意事项与高级技巧

1. 返回引用的必要性

返回 ClassName& 是为了支持链式赋值：

MyString a("A"), b("B"), c("C");  
a = b = c; // 依赖返回引用的特性

若返回 void，则链式赋值将无法实现。

2. 自赋值检查的优化

虽然自赋值检查（if (this == &other)）是必要的，但频繁的判断可能影响性能。可通过“复制-替换”模式优化：

MyString& operator=(MyString other) { // 接受非 const 对象  
    swap(data, other.data); // 交换指针  
    return *this;  
}

此方法利用拷贝构造函数完成深拷贝，并通过 swap 避免自赋值问题。

3. 赋值运算符的 const 重载

在某些场景下，可能需要为 const 对象提供赋值能力，但需谨慎：

const MyString& operator=(const MyString& other) const; // 不推荐，可能破坏 const 性质

通常应避免为 const 对象重载赋值运算符。

移动赋值运算符（C++11+）

在现代 C++ 中，移动语义（Move Semantics）允许通过移动赋值运算符（operator=&&）高效转移资源所有权，避免不必要的拷贝：

class MyString {  
public:  
    MyString& operator=(const MyString& other); // 拷贝赋值  
    MyString& operator=(MyString&& other) noexcept; // 移动赋值  
};  

MyString& MyString::operator=(MyString&& other) noexcept {  
    if (this == &other) {  
        return *this;  
    }  

    delete[] data; // 释放当前资源  

    data = other.data; // 直接转移指针  
    other.data = nullptr; // 断开源对象的指针  

    return *this;  
}

移动赋值运算符适用于临时对象或不再需要资源的场景（如 std::move），可显著提升性能。

结论

C++ 赋值运算符重载是掌握对象生命周期管理的核心技能。通过自定义赋值行为，开发者可以避免内存泄漏、资源竞争等问题，同时确保代码的健壮性。本文通过代码示例和常见误区的分析，帮助读者理解赋值运算符的实现逻辑，并鼓励在实际项目中结合拷贝构造函数、移动语义等概念，构建高效且安全的类设计。

掌握这一技术后，读者可以进一步探索 RAII（Resource Acquisition Is Initialization）模式、智能指针（如 std::unique_ptr）等高级主题，逐步提升 C++ 编程能力。

最新发布

查看更多文章