当前位置：首页 > java >正文

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

java 2025/6/22 21:36:51

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.总结

特性	描述
定义	特殊成员函数，用于通过已有对象初始化新对象
默认行为	浅拷贝（仅复制成员变量的值，指针成员复制地址）
自定义需求	类包含动态资源时，需显式定义深拷贝的拷贝构造函数
调用时机	对象初始化、函数值传递、函数返回对象
参数要求	必须是同类型对象的引用（通常为 `const` 引用）