C++中通过组合对象实现RAII，将资源生命周期绑定对象生命周期。对象构造时获取资源，析构时自动释放，确保异常安全。如智能指针unique_ptr、shared_ptr管理内存，自定义FileHandle类封装文件操作，lock_guard管理互斥锁，均利用析构函数自动释放资源，避免泄露。
在C++中，通过组合对象来管理资源生命周期，核心在于利用RAII（资源获取即初始化）原则。这意味着我们将资源的生命周期与一个对象的生命周期绑定，当对象创建时获取资源，当对象销毁时释放资源，从而确保资源被及时、正确地管理，即便在异常情况下也能避免泄露。
C++中资源生命周期管理，说到底，就是如何确保你拿到的东西（无论是内存、文件句柄、网络连接还是互斥锁）最终能被妥善归还。我个人觉得，最优雅且健壮的方式，便是拥抱“组合”与RAII（Resource Acquisition Is Initialization）哲学。这不仅仅是一种编程模式，更是一种设计思想，它将资源的生命周期紧密地与对象的生命周期绑定起来。
想象一下，你不再需要手动地在
try-catch块里写
delete或者
fclose。而是让一个“管家”对象来替你完成这一切。这个“管家”就是我们说的组合对象。它内部持有对实际资源的引用或指针，并在自己的构造函数中获取资源，在析构函数中释放资源。这样一来，无论代码执行路径如何跳跃，是正常返回，还是抛出异常，只要“管家”对象出了作用域，它的析构函数就一定会被调用，资源也就自然而然地被清理了。
最常见的例子莫过于智能指针，比如
std::unique_ptr和
std::shared_ptr。它们就是内存资源的“管家”。
unique_ptr独占资源，确保一块内存只被一个指针管理，避免了双重释放的风险；
shared_ptr则通过引用计数，允许多个指针共享资源，并在最后一个
shared_ptr销毁时自动释放。这背后，就是组合的力量：智能指针对象内部组合了一个裸指针，并管理它的生命周期。
立即学习“C++免费学习笔记（深入）”；
#include <memory>
#include <iostream>
#include <fstream>
#include <mutex>
#include <stdexcept> // For std::runtime_error
// 内存资源管理：std::unique_ptr
void process_data_unique() {
auto data = std::make_unique<int>(100); // 构造时分配内存
std::cout << "Data value (unique): " << *data << std::endl;
// ... 各种操作，即使这里抛出异常，data也会在函数结束时自动释放
} // data离开作用域，析构函数调用，内存释放
// 内存资源管理：std::shared_ptr
std::shared_ptr<int> global_data;
void process_data_shared() {
auto local_data = std::make_shared<int>(200);
global_data = local_data; // 引用计数增加
std::cout << "Local data value (shared): " << *local_data << std::endl;
} // local_data离开作用域，但global_data仍持有，内存不释放
void another_function_using_shared() {
if (global_data) {
std::cout << "Global data value (shared): " << *global_data << std::endl;
}
} // global_data离开作用域（如果这是main函数结束），内存释放
// 非内存资源管理：自定义文件句柄包装器
class FileHandle {
private:
FILE* file_ptr;
public:
// 构造函数：获取资源
FileHandle(const char* filename, const char* mode) : file_ptr(nullptr) {
file_ptr = fopen(filename, mode);
if (!file_ptr) {
throw std::runtime_error("Failed to open file.");
}
std::cout << "File opened: " << filename << std::endl;
}
// 析构函数：释放资源
~FileHandle() {
if (file_ptr) {
fclose(file_ptr);
std::cout << "File closed." << std::endl;
}
}
// 禁止拷贝，避免双重释放问题
FileHandle(const FileHandle&) = delete;
FileHandle& operator=(const FileHandle&) = delete;
// 允许移动
FileHandle(FileHandle&& other) noexcept : file_ptr(other.file_ptr) {
other.file_ptr = nullptr;
}
FileHandle& operator=(FileHandle&& other) noexcept {
if (this != &other) {
if (file_ptr) fclose(file_ptr); // 释放当前资源
file_ptr = other.file_ptr;
other.file_ptr = nullptr;
}
return *this;
}
// 获取底层文件指针
FILE* get() const { return file_ptr; }
operator bool() const { return file_ptr != nullptr; } // 便于检查有效性
};
void process_file() {
try {
FileHandle my_file("example.txt", "w"); // 文件打开
if (my_file) {
fprintf(my_file.get(), "Hello, RAII!\n");
// ... 即使这里抛出异常，my_file也会在函数结束时自动关闭
}
} catch (const std::runtime_error& e) {
std::cerr << "Error: " << e.what() << std::endl;
}
} // my_file离开作用域，析构函数调用，文件关闭
// 互斥锁管理：std::lock_guard
std::mutex global_mtx;
void critical_section() {
std::lock_guard<std::mutex> lock(global_mtx); // 构造时加锁
std::cout << "Entering critical section..." << std::endl;
// ... 临界区代码
std::cout << "Exiting critical section." << std::endl;
} // lock离开作用域，析构函数调用，自动解锁
// main函数用于演示
int main() {
process_data_unique 
