C++ 中手动重载赋值运算符（operator=）时实现部分复制的思路和方法

简单来说，这一操作的核心是在重载的赋值运算符函数中，只选择对象的部分成员变量进行拷贝，忽略不需要的成员，从而实现自定义的复制逻辑。我会从重载的基础、部分复制的实现步骤、示例代码和注意事项等方面详细讲解。

一、先明确赋值运算符重载的基础

在 C++ 中，编译器会为类生成默认的赋值运算符 （operator=），它的行为是浅拷贝：逐个拷贝类的所有成员变量。但在以下场景中，我们需要手动重载它：

实现深拷贝（处理指针成员，避免浅拷贝的内存问题）；
实现部分复制（只拷贝部分成员，忽略其他成员）；
增加赋值时的额外逻辑（如日志、数据校验）。

赋值运算符重载的基本格式（必须是类的成员函数）：

cpp

运行

复制代码

类名& operator=(const 类名& other) {
    // 复制逻辑（全部/部分成员）
    return *this; // 返回自身引用，支持链式赋值（a = b = c）
}

二、实现 "部分复制" 的核心思路与步骤

实现部分复制的关键是：在重载函数中，只对需要的成员变量执行赋值操作，不处理不需要的成员。具体步骤如下：

防止自赋值 ：先判断当前对象是否和传入的对象是同一个（this == &other），避免不必要的操作和内存错误。
选择性拷贝成员：只复制需要的成员变量，忽略不需要的成员。
返回自身引用 ：支持链式赋值（如a = b = c）。

三、代码示例：手动重载赋值运算符实现部分复制

我们以一个包含多个成员的类为例，演示如何只复制部分成员：

场景说明

定义一个Student类，包含id（学号）、name（姓名）、score（分数）、age（年龄）四个成员。我们希望赋值时只复制id和name，忽略score和age（比如分数和年龄是动态变化的，不需要随赋值复制）。

完整代码

cpp

运行

复制代码

#include <iostream>
#include <cstring>
using namespace std;

class Student {
public:
    // 成员变量
    int id;         // 需要复制的成员
    char* name;     // 需要复制的成员（指针成员，需深拷贝）
    int score;      // 忽略的成员
    int age;        // 忽略的成员

    // 构造函数
    Student(int id_, const char* name_, int score_, int age_) {
        id = id_;
        // 为name分配内存（深拷贝字符串）
        name = new char[strlen(name_) + 1];
        strcpy(name, name_);
        score = score_;
        age = age_;
    }

    // 析构函数：释放name的内存
    ~Student() {
        delete[] name;
    }

    // 手动重载赋值运算符：只复制id和name，忽略score和age
    Student& operator=(const Student& other) {
        // 步骤1：防止自赋值（关键！避免释放自身内存后再拷贝）
        if (this == &other) {
            return *this;
        }

        // 步骤2：部分复制------只拷贝需要的成员（id和name）
        // 拷贝基本类型成员id
        this->id = other.id;

        // 拷贝指针成员name（深拷贝，避免浅拷贝的问题）
        // 先释放当前对象的name内存，防止内存泄漏
        delete[] this->name;
        // 重新分配内存并拷贝内容
        this->name = new char[strlen(other.name) + 1];
        strcpy(this->name, other.name);

        // 步骤3：忽略score和age------不执行任何赋值操作，保留当前对象的原有值

        // 步骤4：返回自身引用，支持链式赋值
        return *this;
    }

    // 打印对象信息的函数
    void show() const {
        cout << "学号：" << id << "，姓名：" << name 
             << "，分数：" << score << "，年龄：" << age << endl;
    }
};

int main() {
    // 创建两个对象
    Student s1(101, "张三", 90, 18);
    Student s2(102, "李四", 85, 19);

    cout << "赋值前：" << endl;
    s1.show(); // 学号：101，姓名：张三，分数：90，年龄：18
    s2.show(); // 学号：102，姓名：李四，分数：85，年龄：19

    // 执行赋值操作：s2 = s1（只复制id和name，忽略score和age）
    s2 = s1;

    cout << "\n赋值后：" << endl;
    s1.show(); // 学号：101，姓名：张三，分数：90，年龄：18（不变）
    s2.show(); // 学号：101，姓名：张三，分数：85，年龄：19（score和age保留原有值）

    return 0;
}

输出结果与分析

plaintext

复制代码

赋值前：
学号：101，姓名：张三，分数：90，年龄：18
学号：102，姓名：李四，分数：85，年龄：19

赋值后：
学号：101，姓名：张三，分数：90，年龄：18
学号：101，姓名：张三，分数：85，年龄：19

可以看到：

s2的id和name被替换为s1的对应值（实现了部分复制）；
s2的score和age保留了原来的值（被忽略，未复制）。

四、进阶场景：部分复制 + 深拷贝（处理指针成员）

在上面的示例中，name是指针成员，我们在部分复制时做了深拷贝 （重新分配内存并拷贝内容），这是避免浅拷贝问题的关键。如果只做浅拷贝（直接赋值this->name = other.name），会导致两个对象的name指向同一块内存，修改一个会影响另一个，且析构时会重复释放内存导致崩溃。

五、注意事项

必须防止自赋值：这是赋值运算符重载的必写步骤，尤其是当类中有指针成员时，自赋值会导致先释放自身内存，再拷贝时访问已释放的内存，引发崩溃。
指针成员的处理 ：如果类中有指针成员，即使是部分复制，只要拷贝该指针成员，就必须做深拷贝（除非你明确需要共享地址）。
返回自身引用 ：返回*this是为了支持链式赋值（如a = b = c），如果返回void，链式赋值会报错。
部分复制的场景合理性 ：部分复制是业务逻辑驱动的，比如某些成员是动态计算的、或与对象的上下文相关，不需要随赋值复制，此时才适合使用，不要滥用。

总结

C++ 中手动重载赋值运算符实现部分复制 的核心是：在operator=函数中只拷贝需要的成员变量，忽略不需要的成员。
重载时必须先防止自赋值 ，对指针成员需做深拷贝，并返回自身引用以支持链式赋值。
部分复制是基于业务需求的自定义逻辑，适用于某些成员不需要随赋值复制的场景，需注意与深拷贝结合处理指针成员，避免内存问题。