C++对象赋值与拷贝构造函数关系

P粉602998670

发布时间：2025-09-17 13:22:01

671人浏览过

来源于php中文网

原创

拷贝构造函数用于初始化新对象，赋值运算符用于更新已存在对象；当类管理动态资源时，必须自定义二者以实现深拷贝，避免浅拷贝导致的内存泄露或双重释放问题。

c++对象赋值与拷贝构造函数关系

C++中，对象赋值和拷贝构造函数处理的是两种截然不同但又紧密相关的对象数据传递场景。简单来说，拷贝构造函数是在创建一个新对象时，用一个已存在的对象去初始化它；而赋值运算符则是在两个已经存在的对象之间，将一个对象的值赋给另一个。理解它们的区别和各自的工作机制，是避免C++中很多内存错误和资源管理问题的关键。

解决方案

在我看来，C++对象赋值和拷贝构造函数的关系，更像是“新生”与“重塑”的关系。拷贝构造函数负责一个对象的“诞生”，它从另一个对象那里获取“基因”来构建自己。而赋值运算符则像是一个对象的“整容”或“改造”，它已经存在了，只是现在要变得和另一个对象一模一样。

默认情况下，C++会为我们生成一个浅拷贝（shallow copy）的拷贝构造函数和赋值运算符。这意味着它们只会简单地按成员逐个复制。对于那些不涉及动态内存分配或资源管理的类来说，这通常是足够的。但一旦你的类内部持有指针、文件句柄、网络连接或其他需要手动管理资源的成员时，麻烦就来了。浅拷贝会导致多个对象共享同一份资源，这就像是两个家庭共用一把唯一的房子钥匙，一个家庭装修了房子，另一个家庭的房子也跟着变了，甚至一个家庭把房子卖了（析构），另一个家庭的房子就没了（悬空指针或双重释放）。

所以，当你发现你的类需要管理资源时，你就必须亲自出马，定义自己的拷贝构造函数和赋值运算符，来实现深拷贝（deep copy）。这不仅是为了正确地复制数据，更是为了确保每个对象拥有自己独立的资源副本，避免资源泄露、悬空指针或重复释放等灾难性后果。这其中，对“自我赋值”的防范，以及实现时的异常安全，都是我们需要深思熟虑的细节。可以说，正确处理这两者，是C++对象生命周期管理中最基础也是最重要的能力之一。

立即学习“C++免费学习笔记（深入）”；

什么时候会调用拷贝构造函数，什么时候调用赋值运算符？

这其实是很多C++初学者常常混淆的地方，但搞清楚了，对象的行为模式就会清晰很多。

拷贝构造函数被调用的场景，核心在于“初始化一个新对象”：

声明时初始化： 当你用一个已存在的对象去初始化一个新对象时，无论是直接初始化 (
```
MyClass obj2 = obj1;
```
) 还是拷贝初始化 (
```
MyClass obj2(obj1);
```
)，都会调用拷贝构造函数。
函数参数按值传递： 如果你将一个对象作为参数，以值传递的方式传入函数，那么在函数内部会创建一个该对象的副本，这时就会调用拷贝构造函数。
函数返回值按值返回： 当函数返回一个对象时（尤其是在没有RVO/NRVO优化的情况下），也会通过拷贝构造函数创建一个临时对象来承载返回值。
容器操作： 将对象放入标准库容器（如
```
std::vector
```
、
```
std::list
```
）时，如果容器需要存储对象的副本，也会调用拷贝构造函数。

而赋值运算符则是在“两个已经存在的对象之间进行赋值”时被调用：

显式赋值： 当一个已经创建的对象被赋予另一个对象的值时 (
```
obj2 = obj1;
```
)，就会调用赋值运算符。这里
```
obj2
```
已经完成了构造，现在只是要更新它的状态。

记住这个关键点：拷贝构造函数处理的是“新对象的诞生”，而赋值运算符处理的是“已存在对象的更新”。理解这一点，就能避免很多因为混淆两者而导致的逻辑错误。

为什么自定义拷贝构造函数和赋值运算符如此重要？

自定义拷贝构造函数和赋值运算符的重要性，几乎完全围绕着“资源管理”这个核心。当你的类成员中包含指针（尤其是指向动态分配内存的指针）、文件句柄、网络套接字等需要手动管理释放的资源时，默认的浅拷贝行为就会带来一系列严重的问题。

万兴喵影

国产剪辑神器

下载

想象一下，你的

MyClass

对象内部有一个

char*

成员，指向一块动态分配的字符串内存。

浅拷贝构造函数： 如果你使用默认的拷贝构造函数
```
MyClass obj2 = obj1;
```
，
```
obj2
```
内部的
```
char*
```
会直接复制
```
obj1
```
的
```
char*
```
值。这意味着
```
obj1
```
和
```
obj2
```
的
```
char*
```
都指向了同一块内存。当
```
obj1
```
或
```
obj2
```
中的任何一个被析构时，这块内存就会被释放。如果另一个对象也尝试释放这块内存，就会导致“双重释放”（double free）错误，程序很可能崩溃。
浅拷贝赋值运算符： 类似地，如果
```
obj2 = obj1;
```
，
```
obj2
```
原先指向的内存没有被释放就丢失了指针（内存泄露），然后
```
obj2
```
的
```
char*
```
也指向了
```
obj1
```
的内存。同样面临双重释放的风险。

这就是“深拷贝”的用武之地。自定义的拷贝构造函数和赋值运算符允许你：

为新对象分配独立的资源： 而不是简单地复制指针值。对于
```
char*
```
，你需要为
```
obj2
```
分配一块新的内存，然后将
```
obj1
```
指向的字符串内容复制到这块新内存中。
正确管理现有资源： 在赋值操作中，
```
obj2
```
在接收
```
obj1
```
的值之前，可能已经持有自己的资源。赋值运算符需要先释放
```
obj2
```
原有的资源，再分配新资源并复制
```
obj1
```
的内容，以避免内存泄露。

简单来说，自定义它们是为了确保每个对象都是独立的个体，拥有自己独立的资源，不会因为其他对象的生命周期结束而受到影响。这不仅仅是“正确性”的问题，更是程序“健壮性”和“稳定性”的基石。

如何正确实现拷贝构造函数和赋值运算符以避免常见错误？

正确实现拷贝构造函数和赋值运算符，是C++中一个经典且重要的课题，通常被称为“Rule of Three/Five/Zero”。它要求我们在处理资源管理的类时，必须显式地定义它们。

1. 拷贝构造函数的实现： 拷贝构造函数相对直接，它的任务是创建一个新对象。

class MyClass {
public:
    // ... 其他成员
    char* data;
    size_t size;

    // 拷贝构造函数
    MyClass(const MyClass& other) : size(other.size) { // 成员初始化列表
        if (other.data) {
            data = new char[size]; // 分配新内存
            std::memcpy(data, other.data, size); // 复制内容
        } else {
            data = nullptr;
        }
    }
    // ...
};

关键点：

参数必须是
```
const MyClass&
```
，避免无限递归调用拷贝构造函数，并确保不修改源对象。
为所有需要深拷贝的成员分配新内存。
将源对象的内容复制到新分配的内存中。
处理源对象成员为空的情况（如
```
nullptr
```
）。

2. 赋值运算符的实现： 赋值运算符则更复杂一些，因为它涉及到一个已经存在的对象。这里需要考虑自我赋值、异常安全和资源管理。

一个经典的、同时兼顾异常安全和自我赋值检查的实现方式是“Copy-and-Swap”惯用法：

class MyClass {
public:
    // ... 其他成员
    char* data;
    size_t size;

    // 析构函数 (重要，用于释放资源)
    ~MyClass() {
        delete[] data;
    }

    // 拷贝构造函数 (如上所示)
    MyClass(const MyClass& other) : size(other.size) {
        if (other.data) {
            data = new char[size];
            std::memcpy(data, other.data, size);
        } else {
            data = nullptr;
        }
    }

    // 移动构造函数 (C++11及更高版本，用于优化性能)
    MyClass(MyClass&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr; // 将源对象置空，防止其析构时释放资源
        other.size = 0;
    }

    // Swap 函数 (通常作为类的友元或成员函数)
    friend void swap(MyClass& first, MyClass& second) noexcept {
        using std::swap; // 允许ADL查找，也使用std::swap
        swap(first.data, second.data);
        swap(first.size, second.size);
    }

    // 赋值运算符 (使用 Copy-and-Swap 惯用法)
    MyClass& operator=(MyClass other) { // 注意：这里参数是按值传递，会调用拷贝构造函数
        swap(*this, other); // 交换资源
        return *this;       // 返回*this，other析构时会自动释放旧资源
    }

    // 移动赋值运算符 (C++11及更高版本，用于优化性能)
    MyClass& operator=(MyClass&& other) noexcept {
        if (this != &other) { // 自我赋值检查
            delete[] data; // 释放自己的旧资源
            data = other.data;
            size = other.size;
            other.data = nullptr; // 将源对象置空
            other.size = 0;
        }
        return *this;
    }
};

Copy-and-Swap 惯用法的优势：

异常安全： 参数
```
other
```
是按值传递的，这意味着在进入
```
operator=
```
之前，
```
other
```
已经是
```
*this
```
的一个副本了。如果这个拷贝构造过程抛出异常，
```
*this
```
对象的状态不会被改变。如果拷贝成功，
```
swap
```
操作是
```
noexcept
```
的，不会抛出异常。
自我赋值安全：
```
swap(*this, other);
```
会正确处理自我赋值的情况，即使
```
*this
```
和
```
other
```
是同一个对象，交换操作也不会导致资源丢失。
代码复用： 拷贝构造函数被复用，简化了赋值运算符的逻辑。