// 不好: 手动管理资源
void processFile() {
    FILE* fp = fopen("data.txt", "r");
    if (!fp) return;
    
    char* buffer = new char[1024];
    // ... 处理文件 ...
    if (some_error) return;  // 忘记释放 buffer！
    
    delete[] buffer;
    fclose(fp);
}

// 好: RAII 自动管理
void processFileRAII() {
    std::ifstream file("data.txt");  // 构造时打开
    if (!file) return;
    
    std::vector<char> buffer(1024);  // 自动管理内存
    // ... 处理文件 ...
    if (some_error) return;  // 自动清理！
}  // file 和 buffer 自动析构

// RAII 的核心: 资源的生命周期 = 对象的生命周期
// 构造获取资源，析构释放资源

// unique_ptr: 独占所有权
{
    auto ptr = std::make_unique<Widget>(42);  // C++14
    ptr->doSomething();
}  // 自动 delete

// shared_ptr: 共享所有权，引用计数
{
    auto sp1 = std::make_shared<Widget>(42);
    {
        auto sp2 = sp1;  // 引用计数 = 2
    }  // sp2 析构，引用计数 = 1
}  // sp1 析构，引用计数 = 0，delete Widget

// weak_ptr: 不增加引用计数，解决循环引用
class Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev;  // 弱引用，不阻止析构
};

// 使用场景:
// unique_ptr: 工厂函数返回值、独占资源
// shared_ptr: 共享缓存、观察者模式
// weak_ptr: 缓存、打破循环引用

// 不好: 容易忘记释放
Widget* createWidget() {
    return new Widget(42);
}
void useWidget() {
    Widget* w = createWidget();
    w->doSomething();
    delete w;  // 容易忘记
}

// 好: 返回智能指针
std::unique_ptr<Widget> createWidgetSafe() {
    return std::make_unique<Widget>(42);
}
void useWidgetSafe() {
    auto w = createWidgetSafe();
    w->doSomething();
}  // 自动释放

// 用 unique_ptr 管理 C 风格资源
struct FileCloser {
    void operator()(FILE* fp) const {
        if (fp) fclose(fp);
    }
};

using UniqueFile = std::unique_ptr<FILE, FileCloser>;

UniqueFile openFile(const char* path, const char* mode) {
    return UniqueFile(fopen(path, mode));
}

void processFile() {
    auto file = openFile("data.txt", "r");
    if (!file) throw std::runtime_error("Cannot open file");
    
    char buffer[1024];
    size_t n = fread(buffer, 1, sizeof(buffer), file.get());
    // ... 处理数据 ...
}  // file 自动关闭

// 互斥锁的 RAII 包装
class MutexGuard {
    std::mutex& mtx;
public:
    explicit MutexGuard(std::mutex& m) : mtx(m) { mtx.lock(); }
    ~MutexGuard() { mtx.unlock(); }
    MutexGuard(const MutexGuard&) = delete;
    MutexGuard& operator=(const MutexGuard&) = delete;
};

void threadSafeFunction() {
    static std::mutex mtx;
    MutexGuard guard(mtx);  // 构造时加锁
    // ... 临界区 ...
}  // 析构时自动解锁