十一(3) 类，加深对拷贝构造函数的理解

class ClassName {
public:

 // 拷贝构造函数：参数是同类型对象的引用（通常为 const 引用）
 ClassName(const ClassName& other) {
     // 复制 other 的成员变量到当前对象
 }
};

• 参数要求：必须是同类型对象的引用（const ClassName&）。若使用值传递（ClassName other），会导致无限递归调用（因为传递参数时需要拷贝原对象，再次调用拷贝构造函数）。

• 返回值：无显式返回值（但实际通过构造函数直接初始化新对象）。

• const 修饰：习惯上用 const 修饰参数，确保不修改原对象（非强制，但更安全）。

用于利用一个已定义的对象，来定义其同类型的副本对象，即对象克隆

1.拷贝构造函数的作用

拷贝构造函数的核心目的是深拷贝对象的状态，确保新对象与原对象独立。具体应用场景包括：

• 用一个对象初始化另一个对象（如 ClassName obj2 = obj1;）。

• 函数值传递（将对象作为参数传递给函数时，会调用拷贝构造函数创建副本）。

• 函数返回对象（函数返回局部对象时，会调用拷贝构造函数生成临时对象）。

2.默认拷贝构造函数

如果用户未显式定义拷贝构造函数，编译器会自动生成一个默认拷贝构造函数。其默认行为是浅拷贝（Shallow Copy）：

• 对于内置类型成员（如 int、double）：直接复制值。

• 对于指针成员：仅复制指针地址（不复制指针指向的内存）。

• 对于类类型成员：递归调用其拷贝构造函数（若该类有自定义拷贝构造函数）。

默认拷贝构造函数的风险：浅拷贝问题

若类中包含动态分配的资源（如堆内存、文件句柄等），默认的浅拷贝会导致多个对象共享同一块资源。当其中一个对象析构时释放资源，其他对象的指针会变成“野指针”，再次访问会导致未定义行为（如崩溃）。

示例：默认拷贝构造函数的问题

#include <iostream>
#include <cstring>

class String {
private:
    char* data;  // 动态分配的字符数组
    size_t len;

public:
    // 构造函数：初始化字符串
    String(const char* str = "") {
        len = std::strlen(str);
        data = new char[len + 1];  // 分配内存
        std::strcpy(data, str);     // 复制内容
    }

    // 析构函数：释放内存
    ~String() {
        delete[] data;  // 释放动态内存
    }

    // 默认拷贝构造函数（浅拷贝）
    // String(const String& other) = default;  // 编译器自动生成的默认版本
};

int main() {
    String s1("Hello");
    String s2 = s1;  // 调用拷贝构造函数（浅拷贝）

    // s1 和 s2 的 data 指针指向同一块内存！
    // 当 s1 或 s2 析构时，会释放该内存，另一个对象的 data 变为野指针
    return 0;
}

问题：s1 和 s2 的 data 指针指向同一块堆内存。当 main 函数结束时，s2 先析构并释放 data，随后 s1 析构时尝试释放已释放的内存，导致重复释放（Double Free），程序崩溃。

3. 自定义拷贝构造函数（深拷贝）

为解决浅拷贝问题，需显式定义拷贝构造函数，对动态资源进行深拷贝（Deep Copy）：复制指针指向的内容，而非指针本身。

深拷贝拷贝构造函数的实现

class String {
private:
    char* data;
    size_t len;

public:
    // 构造函数
    String(const char* str = "") {
        len = std::strlen(str);
        data = new char[len + 1];
        std::strcpy(data, str);
    }

    // 析构函数
    ~String() {
        delete[] data;
    }

    // 自定义拷贝构造函数（深拷贝）
    String(const String& other) {
        len = other.len;
        data = new char[len + 1];       // 分配新内存
        std::strcpy(data, other.data);  // 复制内容（而非指针）
    }
};

int main() {
    String s1("Hello");
    String s2 = s1;  // 调用自定义拷贝构造函数（深拷贝）

    // s1 和 s2 的 data 指向不同的内存块，析构时互不影响
    return 0;
}

效果：s1 和 s2 的 data 指针指向独立的堆内存，析构时各自释放自己的内存，避免了重复释放问题。

5. 拷贝构造函数的调用时机

拷贝构造函数在以下场景中被自动调用：

(1) 直接初始化新对象

String s1("Hello");
String s2(s1);       // 显式调用拷贝构造函数
String s3 = s1;      // 隐式调用拷贝构造函数（C++ 中允许）

(2) 函数值传递

将对象作为参数按值传递给函数时，会调用拷贝构造函数创建副本：

void printString(const String& s) {  // 引用传递（不调用拷贝构造函数）
    std::cout << s.getData() << std::endl;
}

void printStringByValue(String s) {  // 值传递（调用拷贝构造函数）
    std::cout << s.getData() << std::endl;
}

int main() {
    String s("Hi");
    printString(s);       // 不调用拷贝构造函数（引用传递）
    printStringByValue(s);// 调用拷贝构造函数（创建副本）
    return 0;
}

(3) 函数返回对象

函数返回局部对象时，会调用拷贝构造函数生成临时对象（C++11 后可能优化为移动语义）：

String createString() {
    String s("World");
    return s;  // 调用拷贝构造函数（返回局部对象）
}

int main() {
    String s = createString();  // 可能调用拷贝构造函数（或移动构造函数，若存在）
    return 0;
}

6. 注意事项

(1) 避免参数为值传递

拷贝构造函数的参数必须是引用（const ClassName&），否则会导致无限递归调用：

// 错误示例：参数为值传递（编译错误）
String(const String other) { 
    // 调用拷贝构造函数时需要传递 other，再次调用拷贝构造函数 → 无限递归
}

(2) 与移动构造函数的区别

C++11 引入了移动构造函数（Move Constructor），用于高效转移资源所有权（避免深拷贝）。拷贝构造函数是“复制”，而移动构造函数是“移动”（窃取原对象的资源）。若同时存在移动构造函数和拷贝构造函数，编译器会优先调用移动构造函数（当参数是右值时）。

(3) 显式删除拷贝构造函数

若类不希望被拷贝（如管理唯一资源的类），可显式删除拷贝构造函数（C++11 起支持）：

class UniqueResource {
public:
    UniqueResource() = default;
    UniqueResource(const UniqueResource&) = delete;  // 禁止拷贝
};

7.总结