对象复制:拷贝构造与拷贝赋值

1. 基础概念:新建对象与修改已有对象

拷贝构造使用已有对象初始化一个新对象;拷贝赋值将已有对象的值替换为另一个对象的值。二者的关键区别是目标对象是否已经存在。

1
2
3
4
5
Buffer a(3);
Buffer b(a);       // 拷贝构造
Buffer c = a;      // 拷贝构造,虽然写了等号,但正在定义新对象
Buffer d(5);
d = a;             // 拷贝赋值,d 已经存在

通常的函数形式分别为:

1
2
Buffer(const Buffer& rhs);
Buffer& operator=(const Buffer& rhs);

rhs 表示源对象;const 引用避免为了传参再次复制对象,并允许从只读对象复制。拷贝构造的参数不能直接写成按值的 Buffer rhs,否则传参本身又需要拷贝,无法完成这样的构造过程。

按值传递一个已有左值对象时,形参通常需要拷贝构造;引用参数不会创建这样的副本。函数返回类对象时可能发生复制省略或移动,不能仅按源码里出现了几个变量来数拷贝次数。

2. 默认逐成员复制

编译器生成的复制操作会使用各个成员类型自己的复制操作,复制基类部分与非静态数据成员。静态数据属于类,不随单个对象复制。构造成员时仍按成员声明顺序进行。

  • int 等成员复制数值。
  • string、vector 等成员调用其相应复制操作,复制字符串内容或容器元素。
  • 裸指针复制地址,不会自动复制指向的整块资源。
  • 引用成员在拷贝构造后仍绑定同一个对象,不会生成被引用对象的副本。含引用成员的类,其默认拷贝赋值通常被定义为删除,因为引用不能重新绑定。

因此,默认复制不是简单地将整个对象的字节原样搬运。默认操作还可能因成员不可复制等原因被定义为删除,不能认为任何类都一定能默认复制。

3. 浅拷贝、深拷贝与资源归属

假设 Buffer 用指针 data_ 独占一块动态数组,并在析构时 delete[]。默认复制后,两个指针存储相同地址,这是这里讨论的浅拷贝。

1
2
3
原对象.data_ ──┐
              ├──→ 同一块数组
副本.data_ ────┘

副本析构后,数组释放,原对象中的指针成为悬空指针;原对象继续访问或再次释放这块资源,会产生未定义行为。

深拷贝为副本申请独立存储,再复制其中内容:

1
2
原对象.data_ ──→ 数组 A
副本.data_ ────→ 数组 B,初始内容与 A 相同

指针共享地址本身不一定错误。若指针只观察外部对象、不负责释放,共享可能就是设计意图。首先明确资源归谁、是否允许共享,再决定复制策略。

4. 完整实例:拥有独立数组的类

下面的类允许长度为零,使用 size_t 表示非负长度。它同时处理构造、析构、拷贝构造和拷贝赋值。示例只管理 int 数组,元素复制不会抛异常。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <cstddef>

class Buffer {
    std::size_t size_;
    int* data_;

public:
    explicit Buffer(std::size_t n)
        : size_(n), data_(new int[n]{}) {}

    Buffer(const Buffer& rhs)
        : size_(rhs.size_), data_(new int[rhs.size_]) {
        for (std::size_t i = 0; i < size_; ++i) {
            data_[i] = rhs.data_[i];
        }
    }

    Buffer& operator=(const Buffer& rhs) {
        if (this == &rhs) {
            return *this;
        }

        int* newData = new int[rhs.size_];
        for (std::size_t i = 0; i < rhs.size_; ++i) {
            newData[i] = rhs.data_[i];
        }

        delete[] data_;
        data_ = newData;
        size_ = rhs.size_;
        return *this;
    }

    ~Buffer() { delete[] data_; }

    std::size_t size() const { return size_; }
    int& at(std::size_t i) { return data_[i]; }
    const int& at(std::size_t i) const { return data_[i]; }
};

这里的 at 为简化示例没有检查边界,调用者必须保证 i < size();它与标准容器中会检查边界的 at 不同。实际接口可以加入边界检查。

1
2
3
4
5
6
7
8
Buffer a(3);
a.at(0) = 7;
Buffer b = a;
b.at(0) = 9;   // b 改变,a.at(0) 仍为 7

Buffer c(1);
c = a;         // 释放 c 原来的存储,取得独立副本
c = c;         // 自赋值保持安全

同一个类的成员函数可以访问另一个同类对象的 private 成员,因此读取 rhs.data_ 合法。

赋值时的资源处理顺序

先分配并准备新资源,成功后再释放旧资源。若 new 失败,异常会在原对象改变之前传播,原对象仍保持原来的值。

若先 delete[] 再 new,分配失败时原有资源已经失去,成员指针还可能保留旧地址。对于复制元素本身也可能抛异常的复杂类型,上述裸指针写法还需额外保护,应优先使用自动管理资源的类型。

5. this、自赋值与返回引用

this 是当前对象的指针,*this 表示当前对象。在 a.operator=(b) 中,this 等于 &a,&rhs 等于 &b。

this == &rhs 比较对象身份,而不是比较两个对象内容是否相等。a = a 时源和目标是同一个对象;若先释放目标资源,也会破坏源资源。因此自赋值处理关系到正确性,不只是效率。某些其他赋值实现天然能处理自赋值,不一定都要写显式判断。

operator= 通常返回当前对象的非 const 引用,即 return *this;,避免为返回值再复制一个对象,并支持链式赋值:

1
a = b = c;  // 等价于 a = (b = c)

内层 b = c 返回 b 的引用,外层再将 b 赋给 a。普通的 copy() 成员函数不会自动成为赋值运算符:a.copy(b) 和 a = b 是两个不同调用,除非你在实现中主动让它们关联。

6. 对象计数与拷贝构造

拷贝构造不会先执行无参构造函数体。如果只在无参构造中增加计数,而所有对象析构都减少计数,被复制出来的对象就会漏计。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
class Tracked {
    inline static int count_ = 0;  // C++17
public:
    Tracked() { ++count_; }
    Tracked(const Tracked&) { ++count_; }
    Tracked& operator=(const Tracked&) = default;
    ~Tracked() { --count_; }
    static int count() { return count_; }
};

// 函数体或局部作用域内
// Tracked a;         // 存活数 1
// Tracked b = a;     // 存活数 2
// b = a;            // 仍为 2:赋值没有创建新对象

静态计数不随对象复制,问题在于是否为每次实际构造执行了记账。按值传参也可能创建需要计数的对象。返回对象涉及复制省略和移动时,应根据实际发生的构造与析构分析,不能把某一种输出顺序当成固定规律。

7. 禁止复制、三法则与零法则

禁止复制

如果对象不应该被复制,应同时明确禁止拷贝构造和拷贝赋值:

1
2
3
4
5
6
class NonCopyable {
public:
    NonCopyable() = default;
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
};

它仍可以正常创建对象,但从已有左值复制、按值传递该左值或对已有对象复制赋值都会受到限制。不要把删除拷贝操作理解为任何形式的对象初始化都不能发生。

三法则

如果类需要自己编写析构函数、拷贝构造函数、拷贝赋值中的一个,通常应一起审视另外两个,尤其是类独占裸资源时:

操作必须想清楚的问题
析构谁负责释放资源?
拷贝构造新对象的资源从哪里来?
拷贝赋值已有对象的旧资源怎样处理?

这是设计检查原则,不是要求所有类机械地手写三个函数。现代 C++ 还有移动操作,本篇先集中讨论复制。

零法则

使用资源管理类型作为成员,让它们承担申请、释放和复制工作:

1
2
3
4
5
6
7
8
#include <vector>
#include <cstddef>

class BufferValue {
    std::vector<int> data_;
public:
    explicit BufferValue(std::size_t n) : data_(n) {}
};

这里无需自定义析构、拷贝构造或拷贝赋值,vector 的复制会复制 int 元素。若 vector 保存的是裸指针,复制的仍是指针地址,不能因此推断任何容器都自动深拷贝指向的对象。

相关笔记:c++ 类的构造函数与析构函数、重载运算符和重载函数、static 类成员、const 成员函数与 mutable。

使用 Hugo 构建
主题 Stack 由 Jimmy 设计