C++ 智能指针使用汇总

已于 2024-03-13 21:50:51 修改
阅读量1.2k 收藏 16
点赞数 17
分类专栏： C++ 文章标签： c++ java android
于 2024-01-04 21:38:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32348883/article/details/135396704
版权

1. 概念

C++中堆内存的对象在new之后使用，但是没有delete时会产生内存泄漏的问题。

由于一些其他的面向对象编程语言都提供了一些自动的垃圾回收机制，因此C++在98标准中也引入了智能指针的概念，并在C++11中趋于完善。

使用智能指针可以不用调用delete就自动回收new出的对象。智能指针对象位于栈内存，可以自动回收，此时在智能指针的析构函数中就销毁被管理的堆内存对象，防止堆内存泄漏，这样不需要手动调用delete操作内存。
在这里插入图片描述
C++中一共有四种智能指针：auto_ptr、unique_ptr、shared_ptr、weak_ptr，后三者是C++11引入的，第一个已经被C++11弃用（使用unique_ptr代替）。

智能指针的使用需要引入头文件 #include

2. auto_ptr

C++98的智能指针，目前已经不推荐使用。

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string s;

public:
    Test(string s):s(s)
    {
        cout << s << "构造函数" << endl;
    }

    void show()
    {
        cout << s << "调用成员" << endl;
    }

    ~Test()
    {
        cout << s << "析构函数" << endl;
    }
};


int main()
{
    cout << "主函数开始" << endl;
    {
        cout << "{" << endl;
        // ap1管理对象A
        auto_ptr<Test> ap1(new Test("A"));
        // B把A顶掉了，A析构
        ap1.reset(new Test("B"));
        cout << "------------" << endl;
        auto_ptr<Test> ap2;
        ap2.reset(new Test("C"));
        cout << ap2.get() << endl; // getter返回被管理的堆内存对象地址→对象C
        ap2.get()->show(); // C

        Test* t = new Test("D");
        auto_ptr<Test> ap3(t); // ap3管D，不能手动控制D了
        ap3.release(); // 回归手动释放D模式
        delete t;
        cout << "}" << endl;
    }


    cout << "主函数结束" << endl;
    return 0;
}

思考】为什么auto_ptr被弃用？
auto_ptr的复制语义（主要指拷贝构造函数+赋值运算符）会造成持有的堆内存对象控制权转移给新复制出来的智能指针对象。

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string s;

public:
    Test(string s):s(s)
    {
        cout << s << "构造函数" << endl;
    }

    void show()
    {
        cout << s << "调用成员" << endl;
    }

    ~Test()
    {
        cout << s << "析构函数" << endl;
    }
};


int main()
{
    cout << "主函数开始" << endl;
    {
        cout << "{" << endl;
        auto_ptr<Test> ap1(new Test("A"));
        auto_ptr<Test> ap2(new Test("B"));

        auto_ptr<Test> ap3(ap1); // 拷贝构造函数
        auto_ptr<Test> ap4;
        ap4 = ap2;

        // 观察转移现象
        cout << ap1.get() << endl; // 0
        cout << ap2.get() << endl; // 0
        cout << ap3.get() << endl; // 0x10d1080
        cout << ap4.get() << endl; // 0x10d1220

        cout << "}" << endl;
    }

    cout << "主函数结束" << endl;
    return 0;
}

3. unique_ptr

unique_ptr作为对auto_ptr的改进，对其持有的堆内存资源具有唯一控制权，即从语法层面屏蔽了复制语义。
在这里插入图片描述
此时如果要进行控制权的转移，则需要配合使用move函数。

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string s;

public:
    Test(string s):s(s)
    {
        cout << s << "构造函数" << endl;
    }

    void show()
    {
        cout << s << "调用成员" << endl;
    }

    ~Test()
    {
        cout << s << "析构函数" << endl;
    }
};


int main()
{
    cout << "主函数开始" << endl;
    {
        cout << "{" << endl;
        unique_ptr<Test> up1(new Test("A"));
        unique_ptr<Test> up2(new Test("B"));

        unique_ptr<Test> up3(move(up1)); // 拷贝构造函数
        unique_ptr<Test> up4;
        up4 = move(up2);

        // 观察转移现象
        cout << up1.get() << endl; // 0
        cout << up2.get() << endl; // 0
        cout << up3.get() << endl; // 0x881080
        cout << up4.get() << endl; // 0x881220
        up3.swap(up4); // 交换控制权
        cout << up3.get() << endl; // 0x881080
        cout << up4.get() << endl; // 0x881220

        cout << "}" << endl;
    }


    cout << "主函数结束" << endl;
    return 0;
}

4. shared_ptr

unique_ptr对其持有的资源具有唯一性，shared_ptr可以在多个对象之间共享资源。

shared_ptr有两种构建方式：
● 使用make_shared函数构建
● 使用普通构造函数构建

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string s;

public:
    Test(string s):s(s)
    {
        cout << s << "构造函数" << endl;
    }

    void show()
    {
        cout << s << "调用成员" << endl;
    }

    ~Test()
    {
        cout << s << "析构函数" << endl;
    }
};


int main()
{
    cout << "主函数开始" << endl;
    {
        cout << "{" << endl;
        // 构建方式1：sp1→A
        shared_ptr<Test> sp1 = make_shared<Test>("A");
        // 构建方式2：sp2→B
        shared_ptr<Test> sp2(new Test("B"));
        sp1.get()->show();
        sp2.get()->show();

        cout << "}" << endl;
    }

    cout << "主函数结束" << endl;
    return 0;
}

相比而言，两种构建方式前者比后者：
● 性能更好
使用前者在构建时一次性分配内存；后者要先通过new分配一次堆内存，再构建智能指针的过程中与先前的new对象一起分配第二次内存。
● 更加安全
两步操作没有保证操作的原子性，极端情况下可能出现new成功了，但是智能指针的绑定和创建失败，此时仍然会造成内存泄漏的问题。
● 内存释放延迟
一次性分配内存在释放时可能会比两次分配延迟。
引用计数：每次多一个shared_ptr对资源加以引用，计数将+1；每一个管理此资源的shared_ptr对象销毁时，计数将-1，最后一个shared_ptr销毁时，发现计数变为0，此时释放被管理的资源对象。

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string s;

public:
    Test(string s):s(s)
    {
        cout << s << "构造函数" << endl;
    }

    void show()
    {
        cout << s << "调用成员" << endl;
    }

    ~Test()
    {
        cout << s << "析构函数" << endl;
    }
};


int main()
{
    cout << "主函数开始" << endl;
    shared_ptr<Test> sp3;
    {
        cout << "{" << endl;
        shared_ptr<Test> sp1 = make_shared<Test>("A");
        cout << sp1.use_count() << endl; // 1
        sp1.reset();
        cout << sp1.use_count() << endl; // 0
        sp3 = make_shared<Test>("B");
        sp1 = sp3; // 赋值运算符
        cout << sp3.use_count() << endl; // 2
        cout << "}" << endl;
    }
    cout << sp3.use_count() << endl; // 1
    shared_ptr<Test> sp4(sp3); // 拷贝构造函数
    cout << sp4.use_count() << endl; // 2

    cout << "主函数结束" << endl;
    return 0;
}

5. weak_ptr

weak_ptr并不会影响资源的销毁，是一种不影响计数的智能指针，但是在合适的时机，可以通过weak_ptr获得一个shared_ptr。weak_ptr是协助shared_ptr工作的，无法单独使用。

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string s;

public:
    Test(string s):s(s)
    {
        cout << s << "构造函数" << endl;
    }

    void show()
    {
        cout << s << "调用成员" << endl;
    }

    ~Test()
    {
        cout << s << "析构函数" << endl;
    }
};


int main()
{
    cout << "主函数开始" << endl;
    shared_ptr<Test> sp1 = make_shared<Test>("A");
    {
        cout << "{" << endl;
        weak_ptr<Test> wp1;
        cout << wp1.use_count() << endl; // 0
        wp1 = sp1;
        cout << wp1.use_count() << " " << sp1.use_count() << endl; // 1 1

        cout << "}" << endl;
    }

    cout << sp1.use_count() << endl; // 1
    weak_ptr<Test> wp2(sp1);
    cout << wp2.use_count() << endl; // 1
    wp2.lock(); // 只锁定没有用
    shared_ptr<Test> sp2 = wp2.lock(); // 锁定后保存
    weak_ptr<Test> wp3;
    wp3 = wp2;
    cout << wp3.use_count() << endl; // 2
    cout << sp1.use_count() << " " << sp2.use_count() << " "
            << wp2.use_count() << endl; // 2 2 2

    shared_ptr<Test> sp3 = make_shared<Test>("B");
    wp3 = sp3;
    cout << sp3.use_count() << " " << wp3.use_count() << endl; // 1 1
    sp3.reset();
    cout << wp3.use_count() << endl; // 0
    if(wp3.expired()) // 判断资源是否过期
    {
       cout << "资源已经过期" << endl;
    }else
    {
       sp3 = wp3.lock();
       cout << sp3.use_count() << endl;
    }

    unique_ptr<Test> up(new Test("C"));
    shared_ptr<Test> sp(new Test("D"));
    cout << sizeof(up) << " " << sizeof(sp) << endl; // 4 8

    weak_ptr<Test> wp4 = sp;
    shared_ptr<Test> sp4(wp4); // 复制语义
    cout << sp4.use_count() << endl; // 2

    cout << "主函数结束" << endl;
    return 0;
}
路过的小熊~
关注
专栏目录
C++11中的智能指针unique_ptr、shared_ptr和weak_ptr详解
dvlinker的技术专栏
05-28 3万+
详细讲解C++11中引入的智能指针unique_ptr、shared_ptr和weak_ptr。
C++ 中智能指针的用法
m0_51913750的博客
05-26 1388
C++的智能指针的用法（有具体的C++代码示例）
C++智能指针的用法（全）
最新发布
qq_74811378的博客
08-22 799
unique_ptr 可用于管理 new 出来的动态对象，也可以管理其他需要手动关闭的资源。例如：文件对象。由于 unique_ptr 默认使用 delete、delete[] 来释放被管理的资源。所以，当管理的对象不能通过 delete、delete[] 来释放时，就需要自定义删除器。public:Person(){cout << "构造函数" << endl;~Person(){cout << "析构函数" << endl;cout << "文件被自动关闭" << endl;if (fp!
C++ 智能指针的使用
ISmileLi的博客
07-29 2919
一、动态指针说明 C++中主要使用new和delete来分配和释放内存，但有时候我们常常因为忘记delete而造成内存泄漏的问题。于是C++中出现了智能指针模板类来管理动态内存，以避免因为我们“遗忘”而造成内存泄漏的问题。C++中标准的智能指针有4个:auto_ptr、shared_ptr、unique_ptr、weak_ptr。这4个智能指针的头文件都在memory中。 1、auto_ptr...
c++ 智能指针用法详解
weixin_33980459的博客
12-03 841
本文介绍c++里面的四个智能指针: auto_ptr, shared_ptr, weak_ptr, unique_ptr 其中后三个是c++11支持，并且第一个已经被c++11弃用。 为什么要使用智能指针：我们知道c++的内存管理是让很多人头疼的事，当我们写一个new语句时，一般就会立即把delete语句直接也写了，但是我们不能避免程序还未执行到delete时就跳转了或者在函数中没有执行到最后的...
c++智能指针用法
ljjjjjjjjjjj的博客
12-10 1622
智能指针一共有4个，分别是shared_ptr，unique_ptr，weak_ptr，auto_ptr，最后一个被弃用了，主要是前面三种。作用是自动回收内存，不需要是delete，原理是智能指针内部有个计数器，每当创建一次对象计数加一，销毁一次计数减一，当计数等于0时自动释放对象。
c++智能指针的使用
liyang_nash的专栏
12-08 1066
1.shared_ptrmake_shared shared_ptr 允许多个指针指向同一个对象 unique_ptr 独占所指向的对象 weak_ptr 弱引用 返回类指针 shared_ptr<Foo> factory(T arg) { return make_shared<Foo>(arg); } void func(T arg) { shared_ptr<Foo> p = factory(arg); ...
c++11&14-智能指针要点汇总
12-17
但像java等其他一些语言则不会有这样的问题，为什么呢，因为它们有很好的处理内存的方法，比如java的垃圾回收机制，现在，我们c++终于也有了智能指针。 1. 什么是智能指针 简单地说，智能指针是用对象去管理一个...
c++智能3种指针源码分析汇总
06-19
C++智能指针是C++标准库中提供的一种管理动态内存的对象，它们自动处理对象的生命周期，以防止内存泄漏和悬挂指针的问题。本篇文章将深入解析C++中的三种主要智能指针：`std::unique_ptr`、`std::shared_ptr`和`std:...
【C++】【常见面试题】智能指针
andeyeluguo的博客
08-04 68
可以想象，一个人手指着一块区域，那么这个区域就自动生长一个定时炸弹，定时炸弹显示为1，再来一个人指着，炸弹显示为2，当没有人指的时候，这块区域就会自动爆炸。独有指针，每个指针指向一个内存，是绑定的，同时消。关键词：循环引用，计数失效，内存泄漏。解决方法：使用weak_ptr。1.shared_ptr原理。2.unique_ptr原理。智能指针也是常考的内容。智能指针是为了内存管理。
C++智能指针用法详解
12-22
一、简介 　　由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete，流程太复杂，终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见。 　　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: intrusive_ptr。你可能会想，如此多的智能指
C++智能指针剖析
sayhello_world的博客
08-13 901
为什么要有？什么是智能指针？由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete，流程太复杂，最终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见。为了方便内存回收，便有了智能指针。常见的智能指针0.汇总对于编译器来说，智能指针实际上是一个栈对象，并非指针类型，在栈对象生命期即将结束时，智能指针通过
C++ 智能指针 - 全部用法详解
热门推荐
cpp_learner的博客
08-02 7万+
血的教训？不学智能指针，本人丢了一份工作。
C++智能指针使用详解
BadFlag
03-02 2227
C++智能指针总结概述shared_ptr的基础使用方式成员函数use_count()swap()reset()unique()get()管理数组weak_ptr成员函数lock()expired()unique_ptr成员函数 概述 在开发C++代码时，内存管理是一个很麻烦的事情在编程过程中最好的习惯是谁申请谁释放。但是，常常有人会忘记在new后使用delete、在malloc之后使用free或者最糟糕的是根本不知道谁创建的。这就有了智能指针的用武之地，智能指针可以保证在一定作用域内指针是安全有效，除了作
[C++]智能指针用法
FL1768317420的博客
02-24 1610
智能指针之间不能混用。weak_ptr要和shared_ptr搭配使用，不能单独使用weak_ptr。weak_ptr的lock()使用是要先调用lock()再调用expired()。调用lock()之后use_count+1。
C++智能指针使用和详解
weixin_45295598的博客
10-24 471
智能指针即将资源交给一个对象来管理，在其生命周期内资源一直可用，对象生命周期结束后会自动调用析构释放资源。 C++ STL智能指针主要包括auto_ptr、unique_ptr、unique_ptr、shared_ptr、weak_ptr 在这里插入代码片 ...
【C++】智能指针用法详解（非常实用）
热爱数据库的小胖
10-22 4488
C 语言规定所有变量在使用前必须先定义，指定其类型，并按此分配内存单元。指针变量不同于 整型变量和其他类型的变量，它是专门用来存放地址的，所以必须将它定义为“指针类型”。2、智能指针如果在程序中使用 new从堆（自由存储区）分配内存，等到不需要时，应使用delete将其释放。C++ 引用了智能指针 auto_ptr，以帮助自动完成这个过程。随后的编程体验（尤其是使用STL）表明，需要有更精致的机制。基于程序员的编程体验和 BOOST库提供的解决方案，C++11。
C++培训核心技术资料汇总
6. 智能指针：智能指针是管理动态分配内存的类模板，帮助防止内存泄漏和悬挂指针问题。 7. 强类型系统：C++要求在编译时对变量类型进行严格检查。 8. 操作符重载：C++允许对类操作符进行重载，使得可以对类实例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

路过的小熊~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值