一 什么是深拷贝，什么是浅拷贝？c++
浅拷贝（Shallow Copy）
- 浅拷贝在C++中是默认的复制方式，它复制对象的所有成员变量，但对于指针成员变量，仅复制指针的值（即指向的地址），而不复制指针指向的内容。这样一来，两个对象中的指针成员将指向同一块内存区域。
#include <iostream>class Shallow {
public:int* data;// 指向动态分配的内存的指针Shallow(int d) {data = new int(d);//在堆上分配一个int，并用d的值初始化}// 默认的拷贝构造函数实现浅拷贝Shallow(const Shallow& source) : data(source.data) {std::cout << "Shallow copy constructor" << std::endl;}~Shallow() {delete data;std::cout << "Destructor freeing data" << std::endl;}
};int main() {Shallow obj1(10);Shallow obj2 = obj1; // 浅拷贝std::cout << *obj1.data << std::endl; // 输出 10std::cout << *obj2.data << std::endl; // 输出 10return 0;
}
在这个例子中，obj2是通过浅拷贝构造函数创建的，两个对象中的data指针指向同一块内存区域。如果对象obj2的生命周期结束，析构函数将释放内存，但obj1的data指针将变成悬挂指针。
深拷贝（Deep Copy）
- 深拷贝在C++中涉及到对包含动态分配内存的成员变量进行复制，即分配新的内存，并复制内容，而不是仅复制指针的值。
-
#include <iostream>class Deep { public:int* data;Deep(int d) {data = new int(d);}// 深拷贝构造函数Deep(const Deep& source) {data = new int(*source.data);// 分配新的内存，并复制值std::cout << "Deep copy constructor" << std::endl;}~Deep() {delete data;std::cout << "Destructor freeing data" << std::endl;} };int main() {Deep obj1(10);Deep obj2 = obj1; // 深拷贝std::cout << *obj1.data << std::endl; // 输出 10std::cout << *obj2.data << std::endl; // 输出 10*obj2.data = 20;std::cout << *obj1.data << std::endl; // 输出 10std::cout << *obj2.data << std::endl; // 输出 20return 0; }在这个例子中，
obj2是通过深拷贝构造函数创建的。两个对象各自持有一份独立的内存区域，修改obj2的数据不会影响obj1的数据。
关键点
- 浅拷贝：仅复制指针的值，多个对象共享同一块内存。
- 深拷贝：分配新的内存，并复制指针指向的内容，多个对象拥有独立的内存。
实现深拷贝的细节
- 自定义拷贝构造函数
- 自定义赋值运算符（需要处理自赋值问题）。
- 释放动态内存的析构函数。
完整示例如下：
#include <iostream>class Deep {
public:int* data;Deep(int d) {data = new int(d);}// 深拷贝构造函数Deep(const Deep& source) {data = new int(*source.data);std::cout << "Deep copy constructor" << std::endl;}// 深拷贝赋值运算符Deep& operator=(const Deep& source) {if (this == &source) // 检查自赋值return *this;delete data; // 释放旧内存data = new int(*source.data); // 分配新内存并复制数据std::cout << "Deep assignment operator" << std::endl;return *this;}~Deep() {delete data;std::cout << "Destructor freeing data" << std::endl;}
};int main() {Deep obj1(10);Deep obj2 = obj1; // 深拷贝构造函数obj2 = obj1; // 深拷贝赋值运算符std::cout << *obj1.data << std::endl; // 输出 10std::cout << *obj2.data << std::endl; // 输出 10*obj2.data = 20;std::cout << *obj1.data << std::endl; // 输出 10std::cout << *obj2.data << std::endl; // 输出 20return 0;
}
这个示例展示了如何在C++中正确地实现深拷贝，确保对象完全独立，并正确管理动态内存。
二 什么时候产生默认拷贝构造函数
在C++中，如果没有为类显式定义拷贝构造函数，编译器会自动生成一个默认的拷贝构造函数。默认拷贝构造函数执行的是浅拷贝，也就是说，它逐个成员地复制对象，包括对指针和其他对象成员只复制其地址或引用，而不复制其指向的内容。这种行为在某些情况下可能会导致问题，特别是当类中有动态分配的内存或资源时。
1.什么时候会生成默认拷贝构造函数
- 显式调用拷贝构造函数
- 当你显式地使用拷贝构造函数创建一个对象时：
MyClass obj1; MyClass obj2 = obj1; // 这里调用了拷贝构造函数
- 当你显式地使用拷贝构造函数创建一个对象时：
- 函数参数传递：
- 当一个对象通过值传递给函数时，拷贝构造函数会被调用
void myFunction(MyClass obj) {// do something } MyClass obj; myFunction(obj); // 这里调用了拷贝构造函数
- 当一个对象通过值传递给函数时，拷贝构造函数会被调用
- 函数返回值
- 当一个对象通过值返回时，拷贝构造函数会被调用：
MyClass myFunction() {MyClass obj;return obj; // 这里调用了拷贝构造函数 } MyClass obj = myFunction();
- 当一个对象通过值返回时，拷贝构造函数会被调用：
- 类对象的成员初始化：
- 当类中包含其他类的对象成员时，包含类的拷贝构造函数会调用这些成员对象的拷贝构造函数。
2.默认拷贝构造函数的行为
默认拷贝构造函数执行的是逐成员复制，即：
- 对于内置类型的成员（如
int、char等），直接复制其值。 - 对于指针类型的成员，仅复制指针的值（即地址），不复制指针指向的内容。
- 对于类类型的成员，调用其拷贝构造函数（这意味着如果成员类也没有定义拷贝构造函数，编译器会为它们生成默认的拷贝构造函数）。
以下是一个使用默认拷贝构造函数的示例：
#include <iostream>class MyClass {
public:int value;int* ptr;MyClass(int val) : value(val) {ptr = new int(val);}// 默认拷贝构造函数将会逐成员复制// MyClass(const MyClass& source) = default;~MyClass() {delete ptr;}
};int main() {MyClass obj1(10);MyClass obj2 = obj1; // 调用默认拷贝构造函数// 修改obj2中的指针指向的值*obj2.ptr = 20;// 查看obj1和obj2中的值std::cout << "obj1 value: " << obj1.value << ", obj1 ptr value: " << *obj1.ptr << std::endl;std::cout << "obj2 value: " << obj2.value << ", obj2 ptr value: " << *obj2.ptr << std::endl;return 0;
}
obj1 value: 10, obj1 ptr value: 20
obj2 value: 10, obj2 ptr value: 20
在这个示例中，obj2通过默认拷贝构造函数从obj1创建，两个对象中的ptr成员指向同一块内存。因此，修改obj2.ptr的值也会影响obj1.ptr的值。
3.避免默认拷贝构造函数的问题
如果类中包含动态分配的内存或其他需要独立管理的资源，应该显式定义拷贝构造函数来实现深拷贝，以避免共享同一块资源导致的问题。显式定义拷贝构造函数的示例如下：
class MyClass {
public:int value;int* ptr;MyClass(int val) : value(val) {ptr = new int(val);}// 深拷贝构造函数MyClass(const MyClass& source) {value = source.value;ptr = new int(*source.ptr);}~MyClass() {delete ptr;}
};
通过显式定义深拷贝构造函数，obj2和obj1将各自持有独立的内存区域，修改obj2的内容不会影响obj1。
三 虚析构函数的作用？
在C++中，虚析构函数（virtual destructor）对于正确管理多态基类对象的析构操作至关重要。特别是在使用继承和多态的情况下，虚析构函数确保派生类对象在通过基类指针删除时，其析构函数能够被正确调用。
作用和原因
- 正确析构派生类对象：如果一个基类的析构函数不是虚的，通过基类指针删除派生类对象时，只会调用基类的析构函数，而不会调用派生类的析构函数。这会导致派生类中动态分配的资源（如内存、文件句柄等）没有被正确释放，造成资源泄漏。
- 保证析构顺序：在继承层次中，虚析构函数确保删除对象时会按照从派生类到基类的顺序调用析构函数，先析构派生类，再析构基类。这确保了对象的资源被正确地释放。
示例
以下是一个展示虚析构函数作用的简单示例：
#include <iostream>class Base {
public:Base() {std::cout << "Base constructor\n";}virtual ~Base() { // 虚析构函数std::cout << "Base destructor\n";}
};class Derived : public Base {
public:int* data;Derived() {data = new int(42);std::cout << "Derived constructor\n";}~Derived() {delete data;std::cout << "Derived destructor\n";}
};void deleteObject(Base* obj) {delete obj; // 通过基类指针删除对象
}int main() {Base* obj = new Derived();deleteObject(obj); // 正确删除对象return 0;
}
Base constructor
Derived constructor
Derived destructor
Base destructor
详细说明
- 构造函数
- 当创建
Derived对象时，会先调用基类Base的构造函数，然后调用派生类Derived的构造函数。
- 当创建
- 虚析构函数：
- 当通过基类指针
Base*删除派生类对象Derived时，由于基类的析构函数是虚函数，首先会调用派生类Derived的析构函数，释放Derived类中分配的资源。 - 然后调用基类
Base的析构函数，完成基类部分的资源释放。
- 当通过基类指针
- 非虚析构函数的情况：
- 如果
Base的析构函数不是虚函数，删除对象时只会调用Base的析构函数，派生类Derived的析构函数不会被调用，导致派生类中动态分配的资源没有被释放。 -
#include <iostream>class Base { public:Base() {std::cout << "Base constructor\n";}~Base() { // 非虚析构函数std::cout << "Base destructor\n";} };class Derived : public Base { public:int* data;Derived() {data = new int(42);std::cout << "Derived constructor\n";}~Derived() {delete data;std::cout << "Derived destructor\n";} };void deleteObject(Base* obj) {delete obj; // 通过基类指针删除对象 }int main() {Base* obj = new Derived();deleteObject(obj); // 错误删除对象return 0; }
- 如果
Base constructor
Derived constructor
Base destructor
可以看到，没有调用 Derived 的析构函数，导致 data 没有被释放，从而造成内存泄漏。
总结：
虚析构函数在多态基类中至关重要，用于：
- 确保派生类对象被正确析构，释放所有资源，防止资源泄漏。
- 维持正确的析构顺序，从派生类到基类，确保对象的完整析构。
因此，当类可能被继承并通过基类指针或引用操作时，应将析构函数声明为虚函数。
)
)
