C++智能指针有哪些类型 unique_ptr shared_ptr weak_ptr用法（指针.用法.类型.智能.有哪些...）

c++++智能指针主要有unique_ptr、shared_ptr和weak_ptr三种类型，它们基于raii原则实现自动化内存管理，避免内存泄漏和悬空指针问题；unique_ptr提供独占所有权且高效，适用于单一所有者场景；shared_ptr通过引用计数实现共享所有权，适合多对象共用资源的情况；weak_ptr作为弱引用不增加引用计数，用于打破shared_ptr的循环引用并安全观察对象生命周期，三者结合使用可显著提升c++程序的内存安全与代码健壮性。

C++智能指针有哪些类型 unique_ptr shared_ptr weak_ptr用法

C++智能指针主要有三种类型：

unique_ptr

、

shared_ptr

和

weak_ptr

。它们的核心作用在于自动化内存管理，极大简化了C++中资源生命周期的控制，有效避免了内存泄漏和悬空指针等问题。简单来说，它们让C++的内存管理变得更安全、更省心。解决方案

说实话，刚接触C++那会儿，手动管理内存真是个噩梦。

new

了就得记得

delete

，稍微一疏忽，内存泄漏就找上门，程序崩溃更是家常便饭。直到智能指针的出现，才感觉C++在现代编程语言的内存管理上真正迈出了一大步。它们并非什么魔法，而是基于RAII（Resource Acquisition Is Initialization）原则，也就是资源在对象构造时获取，在对象析构时释放。这就像是给内存资源套上了一层“自动回收器”，当智能指针对象超出作用域时，它所管理的内存也会被自动释放掉，省去了我们手动

delete

的烦恼。

这三种智能指针各司其职，解决了不同场景下的内存所有权问题。

unique_ptr

强调独占，

shared_ptr

实现共享，而

weak_ptr

则像是旁观者，用于解决

shared_ptr

可能带来的循环引用问题。理解它们各自的特点和适用场景，是写出健壮C++代码的关键一步。

unique_ptr

的独特所有权与高效管理

unique_ptr

，顾名思义，它拥有对所指向对象的“独占”所有权。这意味着在任何时间点，一个特定的对象只能被一个

unique_ptr

拥有。这种所有权是不能被复制的，但可以被“移动”。我个人觉得，

unique_ptr

是日常开发中最常用也最推荐的智能指针，因为它几乎没有运行时开销，跟原始指针一样高效，却提供了自动释放内存的便利。

它特别适合那些资源必须有且只有一个明确所有者的场景，比如文件句柄、网络连接、或者某个类的内部成员，这些资源一旦被创建，就应该由某个特定的实体负责其生命周期。当你需要将资源的所有权从一个地方转移到另一个地方时，

std::move

就派上用场了。

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

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

void process_resource(std::unique_ptr<MyResource> res) {
    if (res) { // 检查是否为空
        res->do_something();
    }
    // res 在这里超出作用域，MyResource 自动销毁
}

int main() {
    // 创建一个 unique_ptr
    std::unique_ptr<MyResource> ptr1 = std::make_unique<MyResource>(1);
    ptr1->do_something();

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

    // 移动所有权
    std::unique_ptr<MyResource> ptr2 = std::move(ptr1);
    if (!ptr1) { // ptr1 现在是空的
        std::cout << "ptr1 is now empty after move." << std::endl;
    }
    ptr2->do_something();

    // 将所有权传递给函数
    process_resource(std::move(ptr2));
    if (!ptr2) {
        std::cout << "ptr2 is now empty after passing to function." << std::endl;
    }

    // 在容器中使用 unique_ptr
    std::vector<std::unique_ptr<MyResource>> resources;
    resources.push_back(std::make_unique<MyResource>(3));
    resources.push_back(std::make_unique<MyResource>(4));
    // 当 resources 向量超出作用域时，其中的 MyResource 对象也会自动销毁

    std::cout << "Main function ending." << std::endl;
    return 0;
}

使用

std::make_unique

来创建

unique_ptr

是个好习惯，它能避免一些潜在的异常安全问题，并且通常效率更高，因为它只进行一次内存分配。

shared_ptr

如何实现共享所有权与引用计数

有时候，一个资源可能需要被多个地方共同拥有，比如一个配置对象，或者一个大的数据结构，多个模块都需要访问它，并且当最后一个使用者不再需要它时，它才应该被销毁。这时，

shared_ptr

就派上用场了。

shared_ptr

通过引用计数（reference counting）机制来实现共享所有权：每当有一个新的

shared_ptr

指向同一个对象时，引用计数就增加；当一个

shared_ptr

被销毁或指向其他对象时，引用计数就减少。当引用计数归零时，

shared_ptr

会自动删除它所管理的对象。

这种机制听起来很方便，确实也解决了许多复杂场景下的内存管理问题。比如在构建图结构、观察者模式或者缓存系统时，

shared_ptr

能让逻辑变得清晰很多。

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

class SharedResource {
public:
    SharedResource(int id) : id_(id) {
        std::cout << "SharedResource " << id_ << " created." << std::endl;
    }
    ~SharedResource() {
        std::cout << "SharedResource " << id_ << " destroyed." << std::endl;
    }
    void use() {
        std::cout << "SharedResource " << id_ << " is being used." << std::endl;
    }
private:
    int id_;
};

int main() {
    std::shared_ptr<SharedResource> ptrA = std::make_shared<SharedResource>(100);
    std::cout << "ptrA ref count: " << ptrA.use_count() << std::endl; // 1

    std::shared_ptr<SharedResource> ptrB = ptrA; // 复制所有权
    std::cout << "ptrA ref count: " << ptrA.use_count() << std::endl; // 2
    std::cout << "ptrB ref count: " << ptrB.use_count() << std::endl; // 2

    {
        std::shared_ptr<SharedResource> ptrC = ptrA; // 再次复制
        std::cout << "ptrA ref count: " << ptrA.use_count() << std::endl; // 3
        ptrC->use();
    } // ptrC 超出作用域，引用计数减1

    std::cout << "ptrA ref count after C out of scope: " << ptrA.use_count() << std::endl; // 2

    ptrB.reset(); // ptrB 放弃所有权，引用计数减1
    std::cout << "ptrA ref count after B reset: " << ptrA.use_count() << std::endl; // 1

    // 当 ptrA 超出作用域时，引用计数变为0，SharedResource 100 被销毁
    std::cout << "Main function ending." << std::endl;
    return 0;
}

同样，

std::make_shared

是创建

shared_ptr

的首选方式，因为它能在一个内存块中同时分配对象本身和引用计数器，这比先

new

对象再用

shared_ptr

管理要高效得多。不过，

shared_ptr

也有它的缺点，最主要的就是循环引用问题，这正是

weak_ptr

存在的理由。

weak_ptr

为何能打破循环引用并安全观察

shared_ptr

虽然强大，但它有一个著名的“坑”：循环引用。如果两个或多个

shared_ptr

相互持有对方的引用，那么它们的引用计数永远不会降到零，导致内存泄漏。比如，对象A有一个

shared_ptr

指向B，对象B有一个

shared_ptr

指向A，它们会形成一个死循环，谁也无法释放。

weak_ptr

就是为了解决这个问题而生的。它是一种不拥有对象所有权的智能指针，它只是对

shared_ptr

所管理对象的一个“弱引用”或者说“观察者”。

weak_ptr

不会增加对象的引用计数，所以它不会阻止对象被销毁。当你需要访问

weak_ptr

所指向的对象时，你需要先调用它的

lock()

方法，尝试获取一个

shared_ptr

。如果对象仍然存在，

lock()

会返回一个有效的

shared_ptr

；如果对象已经被销毁，它会返回一个空的

shared_ptr

。

这使得

weak_ptr

非常适合用于那些需要访问但又不能拥有所有权的场景，比如缓存管理器（缓存项不应该阻止自身被清理）、父子关系（子节点可以强引用父节点，但父节点对子节点使用弱引用，避免循环）、或者观察者模式中观察者对被观察者的引用。

#include <iostream>
#include <memory>

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:
    std::weak_ptr<A> a_ptr; // 使用 weak_ptr 避免循环引用
    B() { std::cout << "B created." << std::endl; }
    ~B() { std::cout << "B destroyed." << std::endl; }
    void check_a() {
        if (auto sharedA = a_ptr.lock()) { // 尝试获取 shared_ptr
            std::cout << "B can still access A." << std::endl;
        } else {
            std::cout << "A has been destroyed." << std::endl;
        }
    }
};

int main() {
    std::cout << "--- Demonstrating shared_ptr circular reference (conceptual) ---" << std::endl;
    // 如果这里 A 和 B 都用 shared_ptr 互相引用，它们将永远不会被销毁
    // 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; // 引用计数永远不会归零

    std::cout << "\n--- Demonstrating weak_ptr breaking circular reference ---" << std::endl;
    std::shared_ptr<A> a_obj = std::make_shared<A>();
    std::shared_ptr<B> b_obj = std::make_shared<B>();

    a_obj->b_ptr = b_obj; // A 强引用 B
    b_obj->a_ptr = a_obj; // B 弱引用 A

    std::cout << "A ref count: " << a_obj.use_count() << std::endl; // 1 (只有 b_obj->a_ptr 不增加引用计数)
    std::cout << "B ref count: " << b_obj.use_count() << std::endl; // 2 (a_obj->b_ptr 和 b_obj 自身)

    b_obj->check_a(); // A 还在，可以访问

    // 销毁 a_obj
    a_obj.reset(); 
    std::cout << "A ref count after reset: " << (a_obj ? a_obj.use_count() : 0) << std::endl; // 0
    std::cout << "B ref count after A reset: " << b_obj.use_count() << std::endl; // 1 (只有 b_obj 自身)

    b_obj->check_a(); // A 已经销毁，无法访问

    std::cout << "Main function ending." << std::endl;
    return 0;
}

通过

weak_ptr

，我们可以安全地检查对象是否存在，并在需要时临时提升为

shared_ptr

进行操作，避免了内存泄漏的风险。这在设计复杂的、相互关联的对象系统时，显得尤为重要。

总结一下，C++的智能指针家族为我们提供了强大的工具来管理动态内存。

unique_ptr

是默认首选，用于独占所有权；

shared_ptr

用于共享所有权，但要小心循环引用；而

weak_ptr

则是

shared_ptr

的完美搭档，用于打破循环引用并安全地观察对象生命周期。理解并恰当使用它们，能让我们的C++代码更加健壮和高效。

以上就是C++智能指针有哪些类型 unique_ptr shared_ptr weak_ptr用法的详细内容，更多请关注知识资源分享宝库其它相关文章！

C++智能指针有哪些类型 unique_ptr shared_ptr weak_ptr用法（指针.用法.类型.智能.有哪些...）

最近发表

标签列表

C++智能指针有哪些类型 unique_ptr shared_ptr weak_ptr用法（指针.用法.类型.智能.有哪些...）

相关阅读

C++机器人开发 ROS框架环境配置（机器人.框架.配置.环境.开发...）

在Visual Studio中如何调试C++内存错误（调试.内存.错误.Visual.Studio...）

C++函数返回指针 局部变量地址问题（指针.变量.局部.函数.返回...）

C++游戏引擎开发 简单渲染循环实现（渲染.循环.简单.引擎.开发...）

C++金融回测环境 历史数据高速读取优化（历史数据.读取.优化.环境.金融...）

C++异常资源清理 局部对象析构保证（局部.清理.异常.对象.保证...）

最近发表

标签列表

C++函数返回指针局部变量地址问题（指针.变量.局部.函数.返回...）

C++游戏引擎开发简单渲染循环实现（渲染.循环.简单.引擎.开发...）

C++金融回测环境历史数据高速读取优化（历史数据.读取.优化.环境.金融...）

C++异常资源清理局部对象析构保证（局部.清理.异常.对象.保证...）