C++如何使用组合对象管理资源生命周期

try-catch

delete

fclose

std::unique_ptr

std::shared_ptr

unique_ptr

shared_ptr

shared_ptr

#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