c++处理资源管理的核心是raii思想，通过智能指针实现自动内存管理。1. unique_ptr用于独占所有权，确保单一所有者销毁时释放资源；2. shared_ptr用于共享所有权，通过引用计数自动释放资源；3. weak_ptr作为观察者避免循环引用问题。智能指针相比原始指针更安全、简洁，还可通过自定义删除器管理其他资源如文件句柄。选择智能指针应根据所有权需求：仅需一个所有者用unique_ptr，多个所有者用shared_ptr，解决循环引用则用weak_ptr。
C++处理资源管理的核心在于RAII (Resource Acquisition Is Initialization) 思想，也就是在对象构造时获取资源，对象析构时释放资源。智能指针是RAII的一种具体实现，能够自动管理动态分配的内存，避免内存泄漏。
解决方案
C++通过智能指针来优雅地管理资源，特别是动态分配的内存。主要有三种智能指针：
unique_ptr、
shared_ptr和
weak_ptr。
-
unique_ptr
: 独占所有权的智能指针。一个unique_ptr
同一时间只能指向一个对象。当unique_ptr
销毁时，它所指向的对象也会被自动删除。适用于明确只有一个所有者的情况。立即学习“C++免费学习笔记（深入）”；
#include <iostream> #include <memory> class MyClass { public: MyClass() { std::cout << "MyClass created\n"; } ~MyClass() { std::cout << "MyClass destroyed\n"; } void doSomething() { std::cout << "Doing something...\n"; } }; int main() { std::unique_ptr<MyClass> ptr(new MyClass()); // 使用new初始化，C++14后推荐使用make_unique ptr->doSomething(); // std::unique_ptr<MyClass> ptr2 = ptr; // 错误：unique_ptr 不支持复制 std::unique_ptr<MyClass> ptr2 = std::move(ptr); // 正确：使用 std::move 转移所有权 if (ptr2) { ptr2->doSomething(); } if (ptr) { // 此时 ptr 为空 ptr->doSomething(); } return 0; // ptr2 销毁时，MyClass 对象被删除 } -
shared_ptr
: 共享所有权的智能指针。多个shared_ptr
可以指向同一个对象，内部维护一个引用计数。当最后一个指向该对象的shared_ptr
销毁时，对象才会被删除。适用于多个对象需要共享资源的情况。#include <iostream> #include <memory> class MyClass { public: MyClass() { std::cout << "MyClass created\n"; } ~MyClass() { std::cout << "MyClass destroyed\n"; } void doSomething() { std::cout << "Doing something...\n"; } }; int main() { std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>(); std::shared_ptr<MyClass> ptr2 = ptr1; // 共享所有权 ptr1->doSomething(); ptr2->doSomething(); std::cout << "Reference count: " << ptr1.use_count() << std::endl; // 输出引用计数 return 0; // ptr1 和 ptr2 销毁时，引用计数减为 0，MyClass 对象被删除 } -
weak_ptr
:shared_ptr
的观察者，不增加引用计数。用于解决shared_ptr
可能产生的循环引用问题。可以通过weak_ptr
来判断对象是否还存活。#include <iostream> #include <memory> class MyClass; // 前向声明 class ClassA { public: std::shared_ptr<MyClass> myClassPtr; ~ClassA() { std::cout << "ClassA destroyed\n"; } }; class MyClass { public: std::weak_ptr<ClassA> classAPtr; // 使用 weak_ptr 避免循环引用 ~MyClass() { std::cout << "MyClass destroyed\n"; } }; int main() { std::shared_ptr<ClassA> a = std::make_shared<ClassA>(); std::shared_ptr<MyClass> b = std::make_shared<MyClass>(); a->myClassPtr = b; b->classAPtr = a; // weak_ptr 不会增加引用计数 return 0; // 没有循环引用，对象可以正常释放 }
如何选择合适的智能指针？
选择哪种智能指针取决于你的需求。
unique_ptr适用于独占所有权，
shared_ptr适用于共享所有权，
weak_ptr适用于观察者模式并解决循环引用。如果资源只需要一个所有者，那么
unique_ptr是最佳选择，因为它开销最小。只有当多个对象需要共享资源时，才应该使用
shared_ptr。
weak_ptr通常与
shared_ptr配合使用，用于避免循环引用。
智能指针相比原始指针的优势是什么？
智能指针最大的优势在于自动管理内存，避免手动
new和
delete带来的内存泄漏风险。此外，智能指针还提供了一些额外的功能，例如所有权管理、引用计数等，可以更好地控制资源的生命周期。使用原始指针需要手动管理内存，容易出错，并且代码可读性较差。智能指针可以使代码更加安全、简洁和易于维护。
除了内存，智能指针还可以管理其他资源吗？
虽然智能指针主要用于管理动态分配的内存，但实际上，它们也可以用来管理其他类型的资源，例如文件句柄、网络连接、互斥锁等。关键在于自定义删除器（custom deleter）。通过自定义删除器，可以在智能指针销毁时执行特定的清理操作，从而释放相应的资源。例如：
#include <iostream>
#include <memory>
#include <fstream>
class FileDeleter {
public:
void operator()(std::ofstream* file) const {
if (file) {
file->close();
std::cout << "File closed\n";
delete file;
}
}
};
int main() {
std::unique_ptr<std::ofstream, FileDeleter> filePtr(new std::ofstream("example.txt"), FileDeleter());
if (filePtr->is_open()) {
*filePtr << "Hello, world!\n";
}
return 0; // 文件会在 filePtr 销毁时自动关闭
}在这个例子中，
FileDeleter是一个自定义删除器，它负责关闭文件并释放文件句柄。通过将
FileDeleter传递给
unique_ptr的构造函数，我们就可以让
unique_ptr在销毁时自动关闭文件。
如何避免智能指针的循环引用问题？
循环引用是指两个或多个对象互相持有对方的
shared_ptr，导致引用计数永远无法降为 0，从而造成内存泄漏。为了解决这个问题，可以使用
weak_ptr。
weak_ptr是一种弱引用，它不会增加引用计数，因此不会导致循环引用。当需要访问
weak_ptr所指向的对象时，可以先将其转换为
shared_ptr，如果对象仍然存活，则转换成功；否则，转换失败，表示对象已经被销毁。
#include <iostream>
#include <memory>
class ClassA; // 前向声明
class ClassB {
public:
std::weak_ptr<ClassA> aPtr;
~ClassB() { std::cout << "ClassB destroyed\n"; }
};
class ClassA {
public:
std::shared_ptr<ClassB> bPtr;
~ClassA() { std::cout << "ClassA destroyed\n"; }
};
int main() {
std::shared_ptr<ClassA> a = std::make_shared<ClassA>();
std::shared_ptr<ClassB> b = std::make_shared<ClassB>();
a->bPtr = b;
b->aPtr = a; // 使用 weak_ptr 避免循环引用
if (auto sharedAPtr = b->aPtr.lock()) { // 尝试将 weak_ptr 转换为 shared_ptr
std::cout << "ClassA is still alive\n";
} else {
std::cout << "ClassA has been destroyed\n";
}
return 0; // 没有循环引用，对象可以正常释放
} 
