day10（C++）智能指针

已于 2024-10-11 22:38:20 修改
阅读量570 收藏 5
点赞数 17
分类专栏： C++ 文章标签： c++ 开发语言
于 2024-10-11 22:38:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QR70892/article/details/142864771
版权

目录

智能指针

1. 概念

2. auto_ptr 自动指针

3. unique_ptr 唯一指针

4. shared_ptr

5. weak_ptr

6. 窥探源码（了解）

智能指针

1. 概念

C++堆内存对象在new之后使用，如果忘记delete则会产生内存泄漏的问题。

诸如Java、C#等语言直接提供垃圾回收机制来处理不使用的对象，因此在C++98中引入了智能指针的概念，并在C++11中趋于完善。

使用智能指针可以让堆内存对象不调用delete就能被销毁。

智能指针的原理是通过一个栈内存的智能指针对象，控制被管理的堆内存对象生命周期，当栈内存的智能指针对象销毁时，在析构函数中释放被管理管理的堆内存对象。这样程序员就不需要手动调用delete释放堆内存对象了。

C++中有四种只能指针：

  • auto_ptr 自动指针（C++98），已废弃。
  • unique_ptr 唯一指针（C++11）
  • shared_ptr 共享指针（C++11）
  • weak_ptr 虚指针（C++11）

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

2. auto_ptr 自动指针

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

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

    ~Source()
    {
        cout << name << "析构函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }
};

int main()
{
    Source* src = new Source("A");
    // 创建一个智能指针对象ap1，管理对象A
    auto_ptr<Source> ap1(src);
    // 上面的操作可以一步完成
    auto_ptr<Source> ap2(new Source("B"));
    // 被管理的对象可以通过getter拿出来
    ap2.get()->show(); // B
    src = ap2.get();
    src->show(); // B
//    delete src; 乱码：对象内存不能释放两次
    // 解除ap1对A的管理，发返回值为对象A
    src = ap1.release();
    src->show(); // A
    delete src; // 因为A回到手动模式，所以可以delete销毁
    // 解除ap2对B的管理，同时销毁B
    ap2.reset();
    auto_ptr<Source> ap3(new Source("C"));
    // 使用新的资源对象D替代C，C被销毁
    ap3.reset(new Source("D"));

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

auto_ptr真正容易误用的地方是其不常用的复制语义（拷贝构造函数和赋值运算符），与浅拷贝的区别是，auto_ptr的复制语义不会让多个auto_ptr共享一个资源，而是会出现控制权的转移。

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

    ~Source()
    {
        cout << name << "析构函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }
};

int main()
{
    auto_ptr<Source> ap1(new Source("A"));
    cout << ap1.get() << endl; // 0xfa1060
    auto_ptr<Source> ap2(ap1); // 拷贝构造函数
    cout << ap1.get() << " " << ap2.get() << endl; // 0 0xfa1060
    auto_ptr<Source> ap3;
    ap3 = ap2; // 赋值运算符
    cout << ap1.get() << " " << ap2.get()
         << " " << ap3.get() << endl; // 0 0 0xfa1060

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

3. unique_ptr 唯一指针

作为对auto_ptr的改进，unique_ptr对其持有的堆内存对象具有唯一控制权，即不可以转移到其他智能指针管理。

上面的代码中可以看到，所有复制语义都被屏蔽了。

unique_ptr可以增加move函数达到之前控制权转移的效果

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

    ~Source()
    {
        cout << name << "析构函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }
};

int main()
{
    unique_ptr<Source> up1(new Source("A"));
    cout << up1.get() << endl; // 0xfa1060
    unique_ptr<Source> up2(move(up1)); // 拷贝构造函数
    cout << up1.get() << " " << up2.get() << endl; // 0 0xfa1060
    unique_ptr<Source> up3;
    up3 = move(up2); // 赋值运算符
    cout << up1.get() << " " << up2.get()
         << " " << up3.get() << endl; // 0 0 0xfa1060
    // 如果两个unique_ptr对象交换资源，可以使用swap函数
    unique_ptr<Source> up4(new Source("B"));
    unique_ptr<Source> up5(new Source("C"));
    up4.swap(up5);
    up4.get()->show();
    up5.get()->show();

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

4. shared_ptr

shared_ptr可以把持有的资源在多个智能指针之间共享。

shared_ptr除了可以使用构造函数创建外，还可以使用make_shared函数创建。

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

    ~Source()
    {
        cout << name << "析构函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }
};

int main()
{
    shared_ptr<Source> sp1(new Source("A"));
    shared_ptr<Source> sp2 = make_shared<Source>("B");

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

make_shared函数创建相比于普通的构造函数：

  • 性能更好
  • 更加安全
  • 可能内存延迟释放

更推荐使用make_shared函数创建shared_ptr对象。

每个shared_ptr内部都多一个隐藏的成员变量，这个变量通常被称为“引用计数”，每多一个shared_ptr持有资源就计数+1，每少一个shared_ptr持有资源就计数-1，当计数从1变为0时，释放资源。

持有相同资源的shared_ptr对象，引用计数一定相同。

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

    ~Source()
    {
        cout << name << "析构函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }
};

int main()
{
    shared_ptr<Source> sp1 = make_shared<Source>("A");
    cout << sp1.use_count() << endl; // 1
    shared_ptr<Source> sp2(sp1); // 拷贝构造函数
    cout << sp1.use_count() << " " << sp2.use_count() << endl; // 2 2
    sp2.reset(); // 解除sp2对A的管理
    cout << sp1.use_count() << " " << sp2.use_count() << endl; // 1 0
    shared_ptr<Source> sp3;
    sp3 = sp1; // 赋值运算符
    cout << sp1.use_count() << " " << sp3.use_count() << endl; // 2 2
    shared_ptr<Source> sp4 = sp3; // 拷贝构造函数
    cout << sp1.use_count() << endl; // 3
//    shared_ptr<Source> sp5(sp4.get()); 错误
    sp4.get()->show();
    { // 局部代码块
        shared_ptr<Source> sp6;
        sp6 = sp1;
        cout << sp1.use_count() << endl; // 4
    }
    cout << sp1.use_count() << endl; // 3

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

5. weak_ptr

weak_ptr本身无法独立工作，但是可以配合shared_ptr进行工作，weak_ptr对资源对象的管理是一种“弱引用”，因为不会影响引用计数。

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

    ~Source()
    {
        cout << name << "析构函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }
};

int main()
{
    shared_ptr<Source> sp1 = make_shared<Source>("A");
    weak_ptr<Source> wp1 = sp1;
    cout << sp1.use_count() << endl; // 1
    cout << wp1.use_count() << endl; // 1
//    wp1.get(); 无法获取资源
    sp1.reset(); // 计数1→0，对象A销毁
    cout << wp1.use_count() << endl; // 0

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

可以使用expired函数检测虚指针对资源持有的有效性，即资源对象是否已销毁。如果资源对象没有被销毁，可以使用lock函数生成一个shared_ptr对象共享资源。

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

    ~Source()
    {
        cout << name << "析构函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }
};

int main()
{
    shared_ptr<Source> sp1 = make_shared<Source>("A");
    weak_ptr<Source> wp1 = sp1;
//    sp1.reset();
    shared_ptr<Source> sp2;
    // lock能用的前提是资源对象还在
    if(wp1.expired())
    {
        cout << "资源已失效" << endl;
    }else
    {
        sp2 = wp1.lock(); // 返回一个shared_ptr<Source>，但是是临时的，需要保存下来
        cout << sp1.use_count() << " " <<
                sp2.use_count() <<" " << wp1.use_count() << endl; // 2 2 2
    }

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

6. 窥探源码（了解）

经过上述学习可以得到结论：智能指针使用模板实现，堆内存对象和引用计数分别是智能指针对象的成员变量，可以通过sizeof观察到。

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

    ~Source()
    {
        cout << name << "析构函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }
};

int main()
{
    auto_ptr<Source> ap1(new Source("A"));
    cout << sizeof(ap1) << endl; // 4

    unique_ptr<Source> up1(new Source("N"));
    cout << sizeof(up1) << endl; // 4

    shared_ptr<Source> sp1 = make_shared<Source>("S");
    cout << sizeof(sp1) << endl; // 8

    weak_ptr<Source> wp1 = sp1;
    cout << sizeof(wp1) << endl; // 8

    return 0;
}

下面手搓一个简化版的SharedPtr类，简单了解一下智能指针的内部构造，包含以下功能：

  • 构造函数
  • 拷贝构造函数
  • 赋值运算符
  • get函数
  • use_count函数
  • reset函数
  • 析构函数
#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

    ~Source()
    {
        cout << name << "析构函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }
};

template <class T>
class SharedPtr
{
private:
    T* res = NULL;
    int* count = NULL;

public:
    // 构造函数
    SharedPtr(T* t):res(t),count(new int(1)){}

    SharedPtr(const SharedPtr& sp):res(sp.res),count(sp.count)
    {
        (*count)++; // 因为使用的是拷贝构造函数，因此计数+1
    }

    SharedPtr& operator =(const SharedPtr& sp)
    {
        if(this != &sp) // 避免自赋值
        {
            // 如果之前有资源
            // 如果计数>1，计数-1
            // 如果计数=1，计数-1，变0，销毁
            reset();
            res = sp.res;
            count = sp.count;
            (*count)++;
        }
        return *this;
    }

    void reset()
    {
        // 如果之前有资源
        if(res != NULL)
        {
            // 计数-1
            (*count)--;
            if(*count == 0) // 减完之后如果计数为0
            {
                delete res;
                delete count;
            }
            res = NULL;
            count = NULL;
        }
    }

    T* get() const
    {
        return res;
    }

    int use_count() const
    {
        return *count;
    }

    ~SharedPtr()
    {
        reset();
    }
};

int main()
{
    SharedPtr<Source> sp1(new Source("A"));
    SharedPtr<Source> sp2(new Source("B"));
    sp2 = sp1; // A销毁，sp2持有B

    return 0;
}
嵌新程
关注
专栏目录
C++之智能指针
weixin_54940900的博客
03-12 701
RAII是啥子？智能指针怎么传参？所谓的循环引用到底是啥？智能指针如何进行强制类型转换？学完之后感觉智能指针是真的好，真现代，以后写代码看见raw pointers心里都膈应！
C++ 智能指针
努力学习C/C++
06-17 1106
借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：不需要显式地释放资源。采用这种方式，对象所需的资源在其生命期内始终保持有效这里和互斥锁那里是一样的。
C++智能指针详解
qq_61635026的博客
10-02 2025
智能指针是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。下面我们先分析一下下面这段程序有没有什么内存方面的问题？ 关于内存泄漏见文章【C++ 内存管理】RAII（Resource Acquisition Is Initialization），也称为 “资源获取就是初始化” ，是一种利用对象生命周期来控制程序资源（如内存
【C++】智能指针详解
就爱摆烂
05-04 9942
今天我们来讲一下c++11中的智能指针。
【C++】智能指针
fight_p的博客
03-02 2035
为什么需要智能指针呢？有了智能指针带来了什么问题？库里是如何解决的？就不得不说智能指针发展的历史。auto_ptr的解决方法、unique_ptr解决方法、shared_ptr解决方法。shared_ptr线程安全问题、循环引用问题。还有定制删除器。
C++智能指针
2301_80468112的博客
08-27 916
什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
【 C++ 】智能指针
bit_zyx的博客
11-11 1429
目录 1、内存泄漏 什么是内存泄漏，内存泄漏的危害 内存泄漏分类 如何检测内存泄漏（了解） 如何避免内存泄漏 2、为什么需要智能指针 智能指针的使用及原理 RAII（智能指针指导思想） 智能指针的浅拷贝问题 3、C++库里的智能指针 3.1、std::auto_ptr（不推荐） 3.2、std::unique_ptr 3.3
【C++11】智能指针
weixin_60478154的博客
04-02 7750
【C++11】智能指针
C++智能指针总结
weixin_42562387的博客
08-09 921
为什么要有智能指针？ 因为普通的指针存在以下几个问题： 资源泄露 野指针 未初始化 多个指针指向同一块内存，某个指针将内存释放，别的指针不知道 异常安全问题 如果在 malloc和free 或者 new和delete 之间如果存在抛异常，那么也会导致内存泄漏。 资源泄漏示例代码： int main(){ int *p = new int; *p = 1; p = new int; // 未释放之前申请的资源，导致内存泄漏 delete p; return 0; } 野指针示例代
C++智能指针原理与丐版实现
CS_boy的博客
07-12 950
C++中智能指针的原理与简单实现
C++智能指针以及自我实现
qq_44819750的博客
12-05 397
为什么需要智能指针 我们知道，内存泄漏是一件非常严重的错误，这要求如果malloc内存就一定要有对应的free，new了内存也一定要有对应的delete。但是如果程序员忘记写上对应的释放空间的操作符或者函数，那么就会出现内存泄漏，或者程序员写上了，但是中间某个逻辑导致程序崩溃了，并没有走释放空间的语句，那么也会造成内存泄漏，因此，为了防止内存泄漏的发生，C++11中引入了智能指针来管理空间。 内存泄漏 什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存
C++进阶：智能指针
碧瑶的博客呀
10-02 277
为什么需要智能指针 智能指针：管理指针，自动释放资源 智能指针的使用及原理 例如： template <class T> class Smartptr { public: Smartptr(T* ptr = nullptr) :_ptr(ptr) {} ~Smartptr() { if (_ptr) delete[]_ptr; } T& opera...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1277
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
【C++】List
最新发布
m0_46676283的博客
10-08 287
文章目录1.list的介绍及使用1.1 list的介绍 本节目标 1.list的介绍及使用 2.list的深度剖析及模拟实现 3.list与vector的对比 4.本节习题 1.list的介绍及使用 1.1 list的介绍
（STL）map与set的封装--采用红黑树
2302_80190394的博客
10-04 830
（STL）map与set的封装--采用红黑树
C++之多态篇(超详细版)
2302_79795375的博客
10-04 899
public:cout
C++中数据类型的大小
mankeywang的博客
09-30 398
不同数据类型的大小
【STL】queue的模拟实现
gaogo
10-07 246
利用deque实现queue的模拟实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值