构造函数和析构函数管理对象生命周期，前者初始化后者释放资源。构造函数包括默认、拷贝、移动和参数化类型，分别用于无参初始化、复制对象、转移资源和带参初始化。析构函数在对象销毁时自动调用，释放内存等资源，防止泄漏。智能指针如unique_ptr和shared_ptr遵循RAII原则，自动管理内存，避免手动delete，但需注意循环引用问题，weak_ptr可打破循环。程序中合理使用智能指针能有效防止内存泄漏。
构造函数和析构函数是C++中类生命周期管理的核心。构造函数负责对象的初始化，确保对象在使用前处于有效状态；析构函数则负责在对象销毁时进行清理工作，释放资源，防止内存泄漏。它们共同确保了对象的正确创建和销毁。
构造函数和析构函数的使用方法
构造函数在创建对象时自动调用，用于初始化对象的数据成员。析构函数在对象销毁时自动调用，用于释放对象占用的资源。
class MyClass {
public:
// 构造函数
MyClass(int value) : data(value) {
// 构造函数体，进行初始化操作
std::cout << "Constructor called, data = " << data << std::endl;
}
// 析构函数
~MyClass() {
// 析构函数体，进行清理操作
std::cout << "Destructor called, data = " << data << std::endl;
}
private:
int data;
};
int main() {
MyClass obj(10); // 创建对象，调用构造函数
// ... 使用对象 ...
return 0; // 对象销毁，调用析构函数
}构造函数有哪些类型？它们有什么区别？
C++中常见的构造函数类型包括：默认构造函数、拷贝构造函数、移动构造函数和参数化构造函数。
立即学习“C++免费学习笔记（深入）”；
默认构造函数： 没有参数的构造函数。如果类中没有显式定义构造函数，编译器会自动生成一个默认构造函数。但如果类中定义了任何其他构造函数，编译器就不会再自动生成默认构造函数，此时如果需要无参构造，必须显式定义。
拷贝构造函数： 接受一个同类型对象作为参数，用于创建一个新对象，是已有对象的一个副本。如果没有显式定义拷贝构造函数，编译器会生成一个默认的拷贝构造函数，它会逐个成员地复制对象。但是，如果类中包含指针成员，默认拷贝构造函数可能导致浅拷贝问题，即多个对象指向同一块内存，当其中一个对象释放内存时，其他对象就会变成悬挂指针。
class MyClass {
public:
MyClass(int value) : data(value), ptr(new int(value)) {} // 参数化构造函数
MyClass(const MyClass& other) : data(other.data), ptr(new int(*(other.ptr))) { // 拷贝构造函数，深拷贝
std::cout << "Copy constructor called" << std::endl;
}
~MyClass() {
delete ptr; // 释放指针指向的内存
std::cout << "Destructor called" << std::endl;
}
private:
int data;
int* ptr;
};-
移动构造函数： 接受一个同类型右值引用作为参数，用于将资源从一个对象转移到另一个对象，避免不必要的拷贝。移动构造函数通常会将源对象的指针设置为
nullptr
，防止源对象在析构时释放资源。
class MyClass {
public:
MyClass(MyClass&& other) : data(other.data), ptr(other.ptr) { // 移动构造函数
other.ptr = nullptr; // 将源对象的指针置空
std::cout << "Move constructor called" << std::endl;
}
};- 参数化构造函数： 接受一个或多个参数的构造函数，用于根据传入的参数初始化对象。
析构函数的作用是什么？什么时候会被调用？
析构函数的主要作用是释放对象占用的资源，例如动态分配的内存、打开的文件句柄、网络连接等。析构函数会在以下几种情况下被调用：
- 对象超出作用域： 当一个局部变量对象超出其作用域时，其析构函数会被自动调用。
-
对象被
delete
删除： 当使用delete
运算符删除一个动态分配的对象时，其析构函数会被调用。 - 程序结束： 当程序结束时，所有全局对象和静态对象的析构函数会被调用。
- 临时对象销毁： 临时对象在表达式结束后会被销毁，并调用其析构函数。
析构函数执行顺序与构造函数相反，先构造的对象后析构。
如何避免内存泄漏？智能指针是解决方案吗？
避免内存泄漏的关键在于确保所有动态分配的内存都能被正确释放。以下是一些常用的方法：
遵循 RAII (Resource Acquisition Is Initialization) 原则： 在对象构造时获取资源，在对象析构时释放资源。这样可以确保资源在任何情况下都能被正确释放，即使发生异常。
-
使用智能指针： 智能指针是一种自动管理内存的指针，可以在对象不再使用时自动释放内存。C++ 中常用的智能指针包括
std::unique_ptr
、std::shared_ptr
和std::weak_ptr
。std::unique_ptr
：独占式智能指针，确保只有一个指针指向对象。当unique_ptr
离开作用域时，会自动释放其管理的内存。
std::unique_ptr
ptr(new int(10)); // 使用 unique_ptr 管理内存 // 不需要手动释放内存，unique_ptr 会自动释放 std::shared_ptr
：共享式智能指针，允许多个指针指向同一个对象。使用引用计数来跟踪对象的引用数量，当引用计数为 0 时，会自动释放其管理的内存。
std::shared_ptr
ptr1(new int(10)); std::shared_ptr ptr2 = ptr1; // 多个 shared_ptr 指向同一个对象 // 当所有 shared_ptr 都离开作用域时，才会释放内存 std::weak_ptr
：弱引用智能指针，不增加对象的引用计数。可以用来检测对象是否仍然存在，但不能通过weak_ptr
直接访问对象。
避免手动管理内存： 尽量避免使用
new
和delete
运算符手动管理内存，而是使用标准库提供的容器和算法，它们会自动管理内存。
智能指针是避免内存泄漏的有效解决方案，但并非万能。在使用智能指针时，需要注意以下几点：
-
避免循环引用： 当两个或多个对象相互持有
shared_ptr
时，可能导致循环引用，使得对象的引用计数永远不为 0，从而导致内存泄漏。可以使用weak_ptr
打破循环引用。 -
正确使用
unique_ptr
和shared_ptr
： 根据对象的生命周期和所有权关系选择合适的智能指针。unique_ptr
适用于独占所有权的情况，shared_ptr
适用于共享所有权的情况。
#include#include class B; // 前向声明 class A { public: std::shared_ptr b_ptr; ~A() { std::cout << "A is destroyed" << std::endl; } }; class B { public: std::weak_ptr a_ptr; // 使用 weak_ptr 打破循环引用 ~B() { std::cout << "B is destroyed" << std::endl; } }; int main() { std::shared_ptr a = std::make_shared(); std::shared_ptr b = std::make_shared(); a->b_ptr = b; b->a_ptr = a; return 0; }
