【C++】拷贝构造函数

拷贝构造函数的基本概念

拷贝构造函数是C++中一种特殊的构造函数，它使用同类型的已有对象来初始化新创建的对象。其核心作用是确保对象被正确复制，在以下场景中至关重要：

• 对象初始化时的复制操作

• 函数参数按值传递

• 函数返回对象值

默认拷贝构造函数会逐成员复制（member-wise copy），对于简单数据类型（如int、float等）完全够用，但对于包含指针或动态分配资源的类，这种浅拷贝行为可能导致严重问题。

拷贝构造函数的语法与声明

标准拷贝构造函数的声明形式为：

class MyClass {
public:
    MyClass(const MyClass& other);  // 拷贝构造函数
};

自定义拷贝构造函数示例：

class String {
    char* data;
    size_t length;
public:
    // 自定义拷贝构造函数
    String(const String& other) : length(other.length) {
        data = new char[length + 1];
        std::strcpy(data, other.data);
    }
};

浅拷贝与深拷贝的区别

浅拷贝问题

class ShallowCopy {
    int* ptr;
public:
    ShallowCopy(int val) : ptr(new int(val)) {}
    ~ShallowCopy() { delete ptr; }
    // 默认拷贝构造函数执行浅拷贝
};

void problemDemo() {
    ShallowCopy obj1(10);
    ShallowCopy obj2 = obj1;  // 危险！两个对象共享同一指针
}  // 双重释放导致程序崩溃

深拷贝解决方案

class DeepCopy {
    int* ptr;
public:
    DeepCopy(int val) : ptr(new int(val)) {}
    
    // 自定义深拷贝
    DeepCopy(const DeepCopy& other) : ptr(new int(*other.ptr)) {}
    
    ~DeepCopy() { delete ptr; }
};

拷贝构造函数的调用场景

1. 显式初始化：

   MyClass obj1;
   MyClass obj2 = obj1;  // 调用拷贝构造函数

2. 函数参数传递：

   void processObject(MyClass obj);  // 按值传递时调用拷贝构造

3. 函数返回值（可能被优化）：

4. MyClass createObject() {
       MyClass obj;
       return obj;  // 可能调用拷贝构造（NRVO优化可能消除）
   }

拷贝构造函数与移动构造函数的对比

特性	拷贝构造函数	移动构造函数
参数类型	const T&	T&&
资源处理方式	创建新资源副本	转移资源所有权
性能开销	较高（需分配新资源）	极低（仅指针交换）
适用场景	需要独立副本时	临时对象或显式转移所有权时

移动构造函数示例：

class Movable {
    int* resource;
public:
    Movable(Movable&& other) noexcept 
        : resource(other.resource) {
        other.resource = nullptr;  // 确保源对象处于有效状态
    }
};

拷贝控制的三法则与五法则

三法则（Rule of Three）

如果一个类需要自定义以下任一成员函数，则通常需要全部三个：

1. 拷贝构造函数

2. 拷贝赋值运算符

3. 析构函数

五法则（C++11扩展）

在三个基础之上增加：
4. 移动构造函数
5. 移动赋值运算符

完整示例：

class RuleOfFive {
    int* data;
public:
    // 1. 析构函数
    ~RuleOfFive() { delete data; }
    
    // 2. 拷贝构造函数
    RuleOfFive(const RuleOfFive& other) 
        : data(new int(*other.data)) {}
    
    // 3. 拷贝赋值
    RuleOfFive& operator=(const RuleOfFive& other) {
        if (this != &other) {
            delete data;
            data = new int(*other.data);
        }
        return *this;
    }
    
    // 4. 移动构造函数
    RuleOfFive(RuleOfFive&& other) noexcept 
        : data(other.data) {
        other.data = nullptr;
    }
    
    // 5. 移动赋值
    RuleOfFive& operator=(RuleOfFive&& other) noexcept {
        if (this != &other) {
            delete data;
            data = other.data;
            other.data = nullptr;
        }
        return *this;
    }
};

实际应用中的注意事项

1. 禁用拷贝：

   class NonCopyable {
   public:
       NonCopyable(const NonCopyable&) = delete;
       NonCopyable& operator=(const NonCopyable&) = delete;
   };

2. 优先使用智能指针：

   class SafeCopy {
       std::unique_ptr ptr;  // 自动处理深拷贝问题
   public:
       SafeCopy(int val) : ptr(std::make_unique(val)) {}
       // 不需要自定义拷贝构造函数/赋值运算符
   };

3. 性能优化策略：

   • 对大型对象使用移动语义

   • 考虑写时复制（Copy-on-Write）技术

   • 对小对象使用值语义而非指针

4. 异常安全：

   class ExceptionSafe {
       int* ptr1;
       int* ptr2;
   public:
       // 保证拷贝构造的异常安全
       ExceptionSafe(const ExceptionSafe& other) 
           : ptr1(nullptr), ptr2(nullptr) {
           ptr1 = new int(*other.ptr1);
           ptr2 = new int(*other.ptr2);  // 如果失败，析构函数会清理ptr1
       }
   };

   结语

在C++面向对象编程中，拷贝构造函数犹如对象的"基因复制器"，它决定了对象如何被复制和传递。通过本文的探讨，我们深入理解了：

1. 拷贝构造的核心机制 - 从默认的浅拷贝到自定义深拷贝

2. 现代C++的演进 - 从三法则到五法则的扩展

3. 最佳实践方案 - 智能指针与移动语义的巧妙运用

记住这些关键编程哲学：

• 对资源管理类必须实现完整的拷贝控制（五法则）

• 移动语义是性能优化的利器，但不应滥用

• 智能指针能大幅降低手动内存管理的风险

正如C++大师Herb Sutter所言："好的代码应该像科学论文一样，把复杂的问题用简单的方式表达。"拷贝控制正是这种理念的完美体现——表面简单的语法背后，蕴含着资源管理的深刻智慧。