C++如何使用智能指针管理动态资源-C++-PHP中文网

C++智能指针通过RAII管理动态内存，避免泄漏与野指针。std::unique_ptr独占所有权，高效无开销，适用于单一所有者场景；std::shared_ptr共享所有权，用引用计数控制生命周期，适合多所有者共享资源；std::weak_ptr作为弱引用不增计数，解决shared_ptr循环引用问题，常用于观察者或缓存。三者结合可安全高效管理堆资源。

c++如何使用智能指针管理动态资源

C++中，智能指针是管理动态资源（主要是堆内存）的强大工具，它们通过RAII（资源获取即初始化）原则，自动化了内存的生命周期管理，从而有效避免了内存泄漏、野指针和重复释放等常见问题。在我看来，它们是现代C++编程中不可或缺的基石，极大提升了代码的健壮性和可维护性。

解决方案

要有效管理C++中的动态资源，核心在于使用标准库提供的三种智能指针：

std::unique_ptr

登录后复制

、

std::shared_ptr

登录后复制

和

std::weak_ptr

登录后复制

。它们各自拥有不同的所有权语义，适用于不同的场景。简单来说，

unique_ptr

登录后复制

强调独占，资源只能有一个所有者；

shared_ptr

登录后复制

允许多个所有者共享资源，通过引用计数来管理生命周期；而

weak_ptr

登录后复制

则是一种不拥有资源的观察者，主要用于解决

shared_ptr

登录后复制

的循环引用问题。理解并合理运用这三者，几乎可以解决所有基于堆内存的资源管理难题。

std::unique_ptr

登录后复制

：独占所有权的效率之选？

std::unique_ptr

登录后复制

，顾名思义，它代表的是对资源的独占所有权。这意味着一个

unique_ptr

登录后复制

实例是它所管理资源的唯一所有者。一旦

unique_ptr

登录后复制

超出作用域，它所指向的资源就会被自动释放。我个人觉得，这种设计简洁而高效，因为它不需要维护引用计数，几乎没有运行时开销，性能上与裸指针无异。

它的一个显著特点是不可复制，只能通过

std::move

登录后复制

进行所有权的转移。这非常符合“独占”的语义。比如，你有一个函数需要创建一个对象并返回给调用者，但这个对象的所有权应该转移给调用者，这时

unique_ptr

登录后复制

就派上用场了。

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

#include <iostream>
#include <memory>
#include <string>

class MyResource {
public:
    MyResource(const std::string& name) : name_(name) {
        std::cout << "MyResource " << name_ << " created." << std::endl;
    }
    ~MyResource() {
        std::cout << "MyResource " << name_ << " destroyed." << std::endl;
    }
    void doSomething() {
        std::cout << "MyResource " << name_ << " is doing something." << std::endl;
    }
private:
    std::string name_;
};

// 函数返回一个unique_ptr，所有权转移给调用方
std::unique_ptr<MyResource> createResource(const std::string& name) {
    return std::make_unique<MyResource>(name); // 推荐使用make_unique
}

int main() {
    std::cout << "--- unique_ptr example ---" << std::endl;
    std::unique_ptr<MyResource> res1 = createResource("A");
    res1->doSomething();

    // 尝试复制会编译错误：std::unique_ptr<MyResource> res2 = res1;

    // 所有权转移
    std::unique_ptr<MyResource> res2 = std::move(res1);
    if (res1 == nullptr) { // res1现在为空
        std::cout << "res1 is now empty after move." << std::endl;
    }
    res2->doSomething();

    // 当res2超出作用域时，MyResource "A" 将被销毁
    std::cout << "--- unique_ptr example end ---" << std::endl;
    return 0;
}

登录后复制

在我看来，

std::make_unique

登录后复制

是创建

unique_ptr

登录后复制

的最佳实践，它能保证异常安全，并且通常比直接

new

登录后复制

然后包装更高效。

unique_ptr

登录后复制

特别适合那些明确知道资源只有一个所有者的场景，比如文件句柄、网络连接或者一些工厂模式的返回值。

std::shared_ptr

登录后复制

：共享资源的协作模式？

聊完了独占的

unique_ptr

登录后复制

，自然就得说说那更复杂、但同样不可或缺的

std::shared_ptr

登录后复制

了。当多个对象需要共享同一份资源时，

shared_ptr

登录后复制

就是你的不二选择。它通过内部维护一个引用计数器来追踪有多少个

shared_ptr

登录后复制

实例正在指向同一个资源。只有当最后一个

shared_ptr

登录后复制

实例被销毁或重置时，它所管理的资源才会被释放。

这种共享所有权模型非常灵活，尤其在实现一些复杂的数据结构或设计模式时显得尤为重要，比如图结构中的节点、观察者模式中的主题等。我常遇到需要多个模块共同持有某个配置对象或数据缓存的情况，这时候

shared_ptr

登录后复制

就显得游刃有余。

乾坤圈新媒体矩阵管家

新媒体账号、门店矩阵智能管理系统

查看详情

#include <iostream>
#include <memory>
#include <string>
#include <vector>

class SharedResource {
public:
    SharedResource(const std::string& id) : id_(id) {
        std::cout << "SharedResource " << id_ << " created." << std::endl;
    }
    ~SharedResource() {
        std::cout << "SharedResource " << id_ << " destroyed." << std::endl;
    }
    void report() {
        std::cout << "SharedResource " << id_ << " is active." << std::endl;
    }
private:
    std::string id_;
};

int main() {
    std::cout << "--- shared_ptr example ---" << std::endl;
    std::shared_ptr<SharedResource> s_res1 = std::make_shared<SharedResource>("X");
    s_res1->report();
    std::cout << "Reference count for X: " << s_res1.use_count() << std::endl;

    // 复制shared_ptr，引用计数增加
    std::shared_ptr<SharedResource> s_res2 = s_res1;
    std::cout << "Reference count for X: " << s_res1.use_count() << std::endl;

    // 放入容器中，引用计数再次增加
    std::vector<std::shared_ptr<SharedResource>> resources;
    resources.push_back(s_res1);
    std::cout << "Reference count for X: " << s_res1.use_count() << std::endl;

    // s_res2超出作用域，引用计数减少
    {
        std::shared_ptr<SharedResource> s_res3 = s_res1;
        std::cout << "Reference count for X: " << s_res1.use_count() << std::endl;
    } // s_res3销毁
    std::cout << "Reference count for X: " << s_res1.use_count() << std::endl;

    // 当所有shared_ptr实例都销毁后，SharedResource "X" 才会被销毁
    std::cout << "--- shared_ptr example end ---" << std::endl;
    return 0;
}

登录后复制

和

unique_ptr

登录后复制

类似，

std::make_shared

登录后复制

是创建

shared_ptr

登录后复制

的首选方式。它不仅能提供异常安全，还能优化内存分配，将对象本身和其管理块（包含引用计数等信息）一次性分配，减少了内存碎片。不过，

shared_ptr

登录后复制

并非没有缺点，它的主要开销在于需要维护引用计数，这会带来一些性能损耗。更重要的是，它可能会引入一个非常棘手的问题：循环引用。

std::weak_ptr

登录后复制

：打破循环引用的观察者？

这玩意儿，

std::weak_ptr

登录后复制

，我觉得是智能指针家族里最“低调”但又最关键的一员。它不拥有资源，仅仅是

std::shared_ptr

登录后复制

的一个“观察者”或者说“弱引用”。

weak_ptr

登录后复制

不会增加资源的引用计数，因此它的存在不会阻止资源被释放。这使得它成为解决

shared_ptr

登录后复制

循环引用问题的完美方案。

什么是循环引用？想象一下，对象A有一个

shared_ptr

登录后复制

指向对象B，同时对象B也有一个

shared_ptr

登录后复制

指向对象A。这样一来，即使外部已经没有其他

shared_ptr

登录后复制

指向A或B，它们的引用计数永远不会降到零，导致它们永远不会被销毁，造成内存泄漏。这简直是C++程序员的噩梦，但好在标准库给了我们解药。

weak_ptr

登录后复制

通过

lock()

登录后复制

方法可以尝试获取一个

shared_ptr

登录后复制

。如果资源仍然存在（即还有其他

shared_ptr

登录后复制

持有它），

lock()

登录后复制

会返回一个有效的

shared_ptr

登录后复制

；否则，它会返回一个空的

shared_ptr

登录后复制

。

#include <iostream>
#include <memory>
#include <string>

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr;
    A() { std::cout << "A created." << std::endl; }
    ~A() { std::cout << "A destroyed." << std::endl; }
};

class B {
public:
    // 使用weak_ptr打破循环引用
    std::weak_ptr<A> a_ptr;
    B() { std::cout << "B created." << std::endl; }
    ~B() { std::cout << "B destroyed." << std::endl; }
    void checkA() {
        if (auto shared_a = a_ptr.lock()) { // 尝试获取shared_ptr
            std::cout << "B can access A." << std::endl;
        } else {
            std::cout << "A has been destroyed." << std::endl;
        }
    }
};

int main() {
    std::cout << "--- weak_ptr breaking circular reference example ---" << std::endl;
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    // 建立循环引用
    a->b_ptr = b;
    b->a_ptr = a; // 这里使用weak_ptr

    std::cout << "A's ref count: " << a.use_count() << std::endl; // 1 (b_ptr持有B，B的weak_ptr不影响A的计数)
    std::cout << "B's ref count: " << b.use_count() << std::endl; // 1 (a_ptr持有A)

    b->checkA(); // B可以访问A

    // 当a和b超出作用域时，它们将分别被销毁
    // 如果B中a_ptr也是shared_ptr，这里不会调用析构函数
    std::cout << "--- weak_ptr example end ---" << std::endl;
    return 0;
}

登录后复制

除了解决循环引用，