C++如何使用unique_ptr实现独占式资源管理

答案：std::unique_ptr通过独占所有权和RAII原则管理资源，确保同一时间仅一个指针拥有资源，避免内存泄漏；支持自定义删除器以管理非内存资源如文件句柄；可安全转换为std::shared_ptr以实现共享所有权，但需用std::move转移所有权，且应优先使用unique_ptr以减少开销。

C++中，

std::unique_ptr

是一个非常强大的智能指针，它以一种独占所有权的方式管理动态分配的资源。这意味着在任何给定时间，只有一个

unique_ptr

可以指向特定的资源，确保了资源生命周期的清晰和可控，从而有效地避免了内存泄漏和双重释放等问题。它通过RAII（Resource Acquisition Is Initialization）原则，将资源的生命周期与对象的生命周期绑定，在

unique_ptr

对象超出作用域时自动释放其管理的资源。

解决方案

要使用

unique_ptr

实现独占式资源管理，核心在于理解其所有权语义和相关操作。

我们通常会通过

std::make_unique

来创建

unique_ptr

，这是现代C++推荐的做法，因为它能提供异常安全并避免裸指针的使用：

#include 
#include 

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_;
};

int main() {
    // 1. 创建 unique_ptr
    // 推荐使用 std::make_unique，更安全高效
    auto ptr1 = std::make_unique(1);
    ptr1->doSomething();

    // 2. 所有权转移：unique_ptr 是不可复制的，只能通过移动语义转移所有权
    // auto ptr2 = ptr1; // 编译错误！
    std::unique_ptr ptr2 = std::move(ptr1);
    if (ptr1 == nullptr) { // ptr1 现在是空的
        std::cout << "ptr1's ownership has been moved." << std::endl;
    }
    ptr2->doSomething();

    // 3. 获取原始指针 (get())，但不转移所有权
    MyResource* rawPtr = ptr2.get();
    if (rawPtr) {
        rawPtr->doSomething();
    }

    // 4. 释放所有权 (release())，返回原始指针，unique_ptr 变为空
    // 现在需要手动管理 rawPtr_released
    MyResource* rawPtr_released = ptr2.release();
    if (ptr2 == nullptr) {
        std::cout << "ptr2 has released its ownership." << std::endl;
    }
    delete rawPtr_released; // 必须手动删除！

    // 5. 重置 unique_ptr (reset())，释放当前资源并可以指向新资源
    auto ptr3 = std::make_unique(3);
    std::cout << "ptr3 holds resource 3." << std::endl;
    ptr3.reset(new MyResource(4)); // 释放资源3，管理新资源4
    std::cout << "ptr3 now holds resource 4." << std::endl;
    // 如果 reset 不带参数，则释放当前资源并变为空
    ptr3.reset();
    if (ptr3 == nullptr) {
        std::cout << "ptr3 is now empty." << std::endl;
    }

    // 6. unique_ptr 离开作用域时自动销毁资源 (MyResource 2)
    {
        auto ptr_scope = std::make_unique(2);
        std::cout << "Inside scope." << std::endl;
    } // ptr_scope 在这里超出作用域，MyResource 2 被销毁
    std::cout << "Outside scope." << std::endl;

    return 0;
}

这段代码展示了

unique_ptr

的基本生命周期管理和所有权操作。关键在于

std::move

，它明确地表示了所有权的转移，而不是复制。这确保了资源始终只有一个明确的拥有者，大大简化了资源管理的复杂性。

立即学习“C++免费学习笔记（深入）”；

unique_ptr

与

shared_ptr

在资源管理策略上有什么核心差异？

在我看来，理解

unique_ptr

和

shared_ptr

的根本区别，是C++现代资源管理的关键。它们代表了两种截然不同的所有权模型。

unique_ptr

奉行的是独占所有权。它的设计哲学就是“一个萝卜一个坑”，一个资源在任何时候只能被一个

unique_ptr

实例拥有。这种所有权是不可复制的，只能通过移动（

std::move

）来转移。这就意味着一旦一个

unique_ptr

将其所有权转移给另一个

unique_ptr

，它自身就会变为空，不再管理原来的资源。这种模型非常轻量，因为它不需要维护引用计数，所以几乎没有运行时开销，与裸指针的性能相当。它非常适合那些生命周期明确、只有一个明确拥有者的资源，比如函数内部创建并返回的对象，或者某个类的私有成员，代表了该类独有的一个子组件。

而

shared_ptr

则实现了共享所有权。它的核心机制是引用计数。多个

shared_ptr

可以共同拥有同一个资源，每当一个新的

shared_ptr

指向该资源时，引用计数就增加；当一个

shared_ptr

离开作用域或被重置时，引用计数就减少。只有当引用计数降为零时，资源才会被释放。这带来了更大的灵活性，允许资源在多个地方被引用，但同时也引入了额外的开销（引用计数器的维护和存储）。

shared_ptr

适用于那些资源生命周期不确定，需要被多个对象共同引用的场景，比如缓存对象、插件实例等。

所以，我通常的经验是，优先考虑

unique_ptr

。如果你的设计中，一个资源天然就应该只有一个明确的拥有者，那么

unique_ptr

是最佳选择，它提供了清晰的语义和最佳的性能。只有当你确实需要多个对象共享一个资源的生命周期时，才考虑使用

shared_ptr

。不必要的

shared_ptr

会带来不必要的性能损耗和潜在的循环引用问题（虽然可以通过

weak_ptr

解决，但那又是另一个话题了）。

使用

unique_ptr

管理非堆内存资源，例如文件句柄或网络连接，有哪些技巧？

unique_ptr

的强大之处远不止于管理堆内存。通过提供自定义删除器 (custom deleter)，它能够优雅地管理任何需要特定清理操作的资源，例如文件句柄 (

FILE*

)、网络套接字、数据库连接或系统句柄等。这正是RAII原则的精髓所在。

当

unique_ptr

离开作用域时，它默认会调用

delete

来释放其管理的内存。但对于非内存资源，我们需要告诉

unique_ptr

应该如何“删除”或“关闭”它们。这可以通过在

unique_ptr

的模板参数中指定一个自定义删除器来实现。

自定义删除器可以是一个函数对象（包括Lambda表达式）或一个普通函数指针。

例如，管理

FILE*

：

#include 
#include  // For FILE, fopen, fclose
#include 

// 自定义删除器：一个Lambda表达式
auto file_closer = [](FILE* file_ptr) {
    if (file_ptr) {
        std::cout << "Closing file handle..." << std::endl;
        fclose(file_ptr);
    }
};

// unique_ptr 的类型需要指定资源类型和删除器类型
// std::unique_ptr
using UniqueFilePtr = std::unique_ptr;

void processFile(const char* filename) {
    FILE* f = fopen(filename, "r");
    if (!f) {
        std::cerr << "Failed to open file: " << filename << std::endl;
        return;
    }

    // 使用自定义删除器创建 unique_ptr
    UniqueFilePtr file_res(f, file_closer);

    char buffer[256];
    if (fgets(buffer, sizeof(buffer), file_res.get())) {
        std::cout << "Read from file: " << buffer;
    } else {
        std::cout << "Could not read from file or file is empty." << std::endl;
    }

    // file_res 在这里超出作用域时，file_closer 会被调用，自动关闭文件
    std::cout << "File processing finished." << std::endl;
}

int main() {
    // 创建一个临时文件用于测试
    FILE* temp_file = fopen("temp.txt", "w");
    if (temp_file) {
        fprintf(temp_file, "Hello from unique_ptr!\n");
        fclose(temp_file);
    }

    processFile("temp.txt");

    // 顺便提一下，unique_ptr 也可以管理数组
    // unique_ptr 类型会自动使用 delete[]
    auto intArray = std::make_unique(5);
    for (int i = 0; i < 5; ++i) {
        intArray[i] = i * 10;
        std::cout << intArray[i] << " ";
    }
    std::cout << std::endl;
    // intArray 在这里超出作用域时，会自动调用 delete[] intArray;

    return 0;
}

这里的关键是

UniqueFilePtr

的定义，它明确告诉编译器，这个

unique_ptr

管理的是

FILE*

类型的资源，并且在销毁时要调用

file_closer

这个 lambda 函数。这样，无论

processFile

函数如何退出（正常返回、抛出异常），文件句柄都能得到妥善关闭。

对于数组，

unique_ptr

有一个特化版本

std::unique_ptr

，它会自动使用

delete[]

而不是

delete

来释放内存，这使得管理动态数组变得异常方便且安全，省去了手动管理

new[]

和

delete[]

的麻烦。这是一种非常实用的设计，避免了我们为数组资源额外编写自定义删除器。

在哪些情况下，我们可能需要将

unique_ptr

转换为

shared_ptr

，以及如何安全地实现？

将

unique_ptr

转换为

shared_ptr

是一个常见的场景，尤其是在设计系统时，你可能在一个地方以独占所有权的方式创建了一个对象，但随后发现这个对象需要在程序的其他部分被共享。这通常发生在对象生命周期从明确的单一拥有者转变为不确定的多拥有者时。

举个例子，你可能在一个工厂函数中创建了一个对象，这个工厂函数返回一个

unique_ptr

，表示它对新创建的对象拥有独占所有权。然而，调用者可能需要将这个对象注册到一个全局管理器或缓存中，而这个管理器需要以共享所有权的方式来持有对象。在这种情况下，将

unique_ptr

转换为

shared_ptr

就变得非常必要。

如何安全地实现转换：

C++11 提供了直接从

unique_ptr

构造

shared_ptr

的方式。由于

unique_ptr

的所有权是独占的，这种转换本质上是一个所有权转移的过程。

#include 
#include 
#include 

class Gadget {
public:
    Gadget(int id) : id_(id) {
        std::cout << "Gadget " << id_ << " created." << std::endl;
    }
    ~Gadget() {
        std::cout << "Gadget " << id_ << " destroyed." << std::endl;
    }
    void use() {
        std::cout << "Using Gadget " << id_ << std::endl;
    }
private:
    int id_;
};

// 模拟一个工厂函数，创建并返回一个独占的Gadget
std::unique_ptr createGadget(int id) {
    std::cout << "Factory creating Gadget " << id << std::endl;
    return std::make_unique(id);
}

// 模拟一个管理器，它需要共享所有权
std::vector> global_gadget_registry;

void registerGadget(std::shared_ptr gadget) {
    std::cout << "Registering Gadget " << gadget->id_ << " into global registry." << std::endl;
    global_gadget_registry.push_back(std::move(gadget));
}

int main() {
    // 1. 创建一个 unique_ptr
    auto unique_g1 = createGadget(101);
    unique_g1->use();

    // 2. 将 unique_ptr 转换为 shared_ptr
    // 注意：unique_g1 必须通过 std::move 转移所有权
    std::shared_ptr shared_g1 = std::move(unique_g1);

    if (unique_g1 == nullptr) {
        std::cout << "Original unique_g1 is now empty after conversion." << std::endl;
    }
    shared_g1->use(); // shared_g1 现在拥有了资源

    // 3. 将这个 shared_ptr 注册到需要共享所有权的地方
    registerGadget(shared_g1); // shared_g1 仍然有效，因为它被复制到了vector中

    // 4. 再次创建一个 unique_ptr，并直接转换为 shared_ptr 传递
    registerGadget(std::move(createGadget(102))); // 临时 unique_ptr 转换为 shared_ptr

    std::cout << "Exiting main function." << std::endl;
    // 当 main 函数结束时，global_gadget_registry 中的 shared_ptr 也会被销毁
    // 最终 Gadget 101 和 102 会被销毁
    return 0;
}

在这个例子中，

std::move(unique_g1)

是关键。它将

unique_ptr

的所有权“转移”给

shared_ptr

的构造函数。一旦完成转换，原来的

unique_ptr

(

unique_g1

) 就会变为空，不再管理任何资源。此后，

shared_ptr

(

shared_g1

) 将负责管理该对象的生命周期，并维护引用计数。

需要注意的是，这种转换会引入

shared_ptr

的所有开销（引用计数）。因此，除非确实需要共享所有权，否则应尽可能保持使用

unique_ptr

。不必要的转换会增加程序的复杂性和运行时开销。这并非一个性能优化点，而是一个为了适应不同所有权模型而进行的语义转换。