c++如何使用unique_ptr管理资源_c++ unique_ptr独占式智能指针用法

#include <iostream>
#include <memory> // 包含 unique_ptr

class MyResource {
public:
    MyResource(int id) : id_(id) {
        std::cout << "MyResource " << id_ << " created." << std::endl;
    }
    ~MyResource() {
        std::cout << "MyResource " << id_ << " destroyed." << std::endl;
    }
    void doSomething() {
        std::cout << "MyResource " << id_ << " doing something." << std::endl;
    }
private:
    int id_;
};

void processResource(std::unique_ptr<MyResource> res) {
    // res 现在独占了资源
    res->doSomething();
    // 当函数返回时，res 超出作用域，MyResource 会被自动销毁
}

int main() {
    // 1. 使用 std::make_unique 创建 unique_ptr (C++14 推荐)
    // 这是我个人最喜欢的方式，因为它更安全，避免了裸指针的直接操作
    std::unique_ptr<MyResource> ptr1 = std::make_unique<MyResource>(1);
    ptr1->doSomething();

    // 2. 使用 new 关键字直接初始化 unique_ptr (不推荐，但有时会遇到)
    // 这种方式需要注意异常安全，如果 MyResource 构造失败，可能导致内存泄漏
    std::unique_ptr<MyResource> ptr2(new MyResource(2));
    ptr2->doSomething();

    // 3. 转移所有权 (move semantics)
    // ptr1 的所有权被转移到 ptr3，ptr1 变为 nullptr
    std::unique_ptr<MyResource> ptr3 = std::move(ptr1);
    if (ptr1 == nullptr) {
        std::cout << "ptr1 is now empty after move." << std::endl;
    }
    ptr3->doSomething();

    // 4. 将 unique_ptr 作为函数参数或返回值
    // 这也是通过移动语义实现的
    std::cout << "\nCalling processResource..." << std::endl;
    processResource(std::move(ptr3)); // 传递所有权
    std::cout << "processResource returned." << std::endl;
    if (ptr3 == nullptr) {
        std::cout << "ptr3 is now empty after moving to function." << std::endl;
    }

    // 5. reset() 方法：释放当前资源并接管新资源（或不接管）
    std::unique_ptr<MyResource> ptr4 = std::make_unique<MyResource>(4);
    ptr4->doSomething();
    ptr4.reset(new MyResource(5)); // MyResource 4 被销毁，MyResource 5 被创建并由 ptr4 管理
    ptr4->doSomething();
    ptr4.reset(); // MyResource 5 被销毁，ptr4 变为空
    if (ptr4 == nullptr) {
        std::cout << "ptr4 is empty after reset()." << std::endl;
    }

    // 6. get() 方法：获取裸指针，但不放弃所有权
    // 使用时要格外小心，不能通过裸指针删除资源，否则 unique_ptr 会再次删除，导致双重释放
    std::unique_ptr<MyResource> ptr6 = std::make_unique<MyResource>(6);
    MyResource* rawPtr = ptr6.get();
    rawPtr->doSomething(); // 可以通过裸指针操作资源
    // delete rawPtr; // 绝对不要这样做！
    // 当 ptr6 超出作用域时，MyResource 6 会被正确销毁

    // 7. release() 方法：放弃所有权，返回裸指针
    // 此时需要手动管理返回的裸指针，否则会导致内存泄漏
    std::unique_ptr<MyResource> ptr7 = std::make_unique<MyResource>(7);
    MyResource* releasedPtr = ptr7.release();
    if (ptr7 == nullptr) {
        std::cout << "ptr7 is empty after release()." << std::endl;
    }
    releasedPtr->doSomething();
    delete releasedPtr; // 现在必须手动删除

    std::cout << "\nEnd of main function." << std::endl;
    return 0;
}

std::unique_ptr<MyResource> ptrA = std::make_unique<MyResource>(10);
// std::unique_ptr<MyResource> ptrB = ptrA; // 编译错误！unique_ptr不能被复制
// ptrB = ptrA; // 编译错误！unique_ptr不能被复制赋值

std::unique_ptr<MyResource> originalPtr = std::make_unique<MyResource>(11);
std::cout << "Original ptr address: " << originalPtr.get() << std::endl;

// 转移所有权
std::unique_ptr<MyResource> movedPtr = std::move(originalPtr);
std::cout << "Moved ptr address: " << movedPtr.get() << std::endl;

if (originalPtr == nullptr) {
    std::cout << "Original ptr is now null after move." << std::endl;
}
// 此时，originalPtr 已经不再拥有资源，它的内部指针被设置为 nullptr
// movedPtr 现在独占 MyResource(11) 的所有权
movedPtr->doSomething();
// originalPtr->doSomething(); // 运行时错误，因为 originalPtr 为空

#include <iostream>
#include <memory>
#include <cstdio> // For FILE, fopen, fclose

// 方法一：使用 Lambda 表达式 (推荐，尤其当删除逻辑简单时)
void manageFileWithLambda() {
    std::cout << "\n--- Managing file with Lambda deleter ---" << std::endl;
    // 定义一个 lambda 作为删除器
    auto fileDeleter = [](FILE* filePtr) {
        if (filePtr) {
            std::cout << "Closing file using lambda deleter." << std::endl;
            fclose(filePtr);
        }
    };

    // unique_ptr 的模板参数需要指定资源类型和删除器类型
    std::unique_ptr<FILE, decltype(fileDeleter)> file(fopen("test_lambda.txt", "w"), fileDeleter);

    if (file) {
        fprintf(file.get(), "Hello from unique_ptr with lambda!\n");
        std::cout << "File 'test_lambda.txt' written." << std::endl;
    } else {
        std::cerr << "Failed to open file 'test_lambda.txt'." << std::endl;
    }
    // file 超出作用域时，lambda deleter 会被调用
    std::cout << "Exiting manageFileWithLambda." << std::endl;
}

// 方法二：使用函数 (适用于删除逻辑复杂或需要复用时)
void closeFile(FILE* filePtr) {
    if (filePtr) {
        std::cout << "Closing file using function deleter." << std::endl;
        fclose(filePtr);
    }
}

void manageFileWithFunction() {
    std::cout << "\n--- Managing file with function deleter ---" << std::endl;
    // unique_ptr 的模板参数需要指定资源类型和函数指针类型
    std::unique_ptr<FILE, decltype(&closeFile)> file(fopen("test_function.txt", "w"), &closeFile);

    if (file) {
        fprintf(file.get(), "Hello from unique_ptr with function!\n");
        std::cout << "File 'test_function.txt' written." << std::endl;
    } else {
        std::cerr << "Failed to open file 'test_function.txt'." << std::endl;
    }
    std::cout << "Exiting manageFileWithFunction." << std::endl;
}

// 方法三：使用函数对象 (适用于需要状态或更复杂逻辑的删除器)
struct FileCloser {
    void operator()(FILE* filePtr) const {
        if (filePtr) {
            std::cout << "Closing file using functor deleter." << std::endl;
            fclose(filePtr);
        }
    }
};

void manageFileWithFunctor() {
    std::cout << "\n--- Managing file with functor deleter ---" << std::endl;
    // unique_ptr 的模板参数需要指定资源类型和函数对象类型
    std::unique_ptr<FILE, FileCloser> file(fopen("test_functor.txt", "w"), FileCloser());

    if (file) {
        fprintf(file.get(), "Hello from unique_ptr with functor!\n");
        std::cout << "File 'test_functor.txt' written." << std::endl;
    } else {
        std::cerr << "Failed to open file 'test_functor.txt'." << std::endl;
    }
    std::cout << "Exiting manageFileWithFunctor." << std::endl;
}


int main() {
    manageFileWithLambda();
    manageFileWithFunction();
    manageFileWithFunctor();
    return 0;
}