C++智能指针思考

最新推荐文章于 2023-09-14 18:12:29 发布
最新推荐文章于 2023-09-14 18:12:29 发布
阅读量396 收藏
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45963260/article/details/122893088
版权

文章目录

前言

突然发现自己平时不怎么写博客，但是面试的时候面试官对写博客有好印象，所以从今天开始养成写博客的好习惯。昨天学了C++的智能指针，这在我之前的大华笔试的时候做到过，但是当时并没有学，仔细学了一下说一下我的思考

一、智能指针是什么？

C++中堆内存的对象是以指针的形式存在的，使用new来创建，使用delete来销毁。但是在实际的使用过程中很容易出现忘记调用delete的情况，从而造成内存泄露的问题。
诸如Java、C#等面向对象的语言直接提供垃圾回收机制来定期处理不再使用的对象，因此C++在98标准中引入了智能指针的概念，并在C++11中趋于完善。
使用智能指针，就可以让指针不需要调用delete。智能指针主要用于管理堆内存，它将普通的指针封装成一个栈对象。当栈对象的生命周期结束后，会在其析构函数中释放申请的内存，从而防止内存泄露。
C++中有四种智能指针：auto_ptr、unique_ptr、shared_ptr、weak_ptr。其中后三者是C++11中新增的，第一个是C++98增加的。
使用智能指针需要引入头文件 #include

二、智能指针的分类

1.auto_ptr

该指针是在C++98就已经存在，现在已经不推荐使用。
给智能指针赋值为 auto_ptr<类型名> 指针名 (类型的对象);

使用赋值之后的指针的内容用内置函数 .get()
如果要更换指针的指向对象用内置函数 .reset(类型的对象);
reset 更换对象之后，会在构造对象之后将更换之前的对象进行析构

最大的缺点是赋值拷贝会让出所有权

代码如下：

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string s;

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

    void show()
    {
        cout << s << endl;
    }

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

int main()
{
    // 局部代码块
    {
        // 智能指针ap1管理堆内存Test对象
        auto_ptr<Test> ap1(new Test("A"));
        // 先获取堆内存对象后再调用其成员
        ap1.get()->show();
        // 让智能指针换一个管理的对象，之前管理的对象会被销毁
        ap1.reset(new Test("B"));
        ap1.get()->show();
        // 释放对象管理
//        ap1.release(); 不会销毁管理的对象，仅仅是解除关系
    }

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

2.unique_ptr

unique_ptr其实就是在auto_ptr的基础上对拷贝赋值进行了限制。
作为对auto_ptr的改进，unique_ptr对其持有的堆内存对象具有唯一拥有权，即unique_ptr不可以拷贝和赋值给其它对象，其拥有的堆内存对象仅自己独占。同样，unique_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()
{
    {
        unique_ptr<Test> ap1(new Test("A"));
        // 屏蔽了复制的功能
//        unique_ptr<Test> ap2(ap1); 错误
//        unique_ptr<Test> ap3=ap2; 错误
        //  相同
        cout << ap1.get() << endl;
        ap1.get()->show();
        ap1.reset(new Test("B"));

        // 相同
//        ap1.release();
    }
    cout << "主函数执行结束" << endl;
    return 0;
}

3.shared_ptr

因为std::unique_ptr对其持有的资源具有独占性，所以需要使用share_ptr来在多个智能指针之间共享其持有的资源。

shared_ptr 是对unique_ptr和auto_ptr的改进版
有几个特点：
1.创建shared_ptr指针的时候可以使用make_shared<类型名>(类的参数)
对比new之后再将类传给指针的做法更加安全，防止了内存泄漏的危险
2.可以使用内置函数 .use_count()查看被引用次数，也就是赋值次数，这也是比auto_ptr好的一点
例如：
sp1 和 sp2, sp2引用的sp1,那么sp2.use_count()和sp1.use_count()的结果都是一样的
3.shared_ptr是没有.release函数的，但是可以通过 .reset()函数来进行释放，只需要不写参数

#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()
{
    {
        shared_ptr<Test> sp1(new Test("A"));
        cout << sp1.get() << endl;
        sp1.get()->show();

        // 新增构建方式
        shared_ptr<Test> sp2 = make_shared<Test>("B");
        cout << sp2.get() << endl;
        sp2.get()->show();
    }
    cout << "主函数执行结束" << endl;
    return 0;
}

shared_ptr比auto_ptr优秀地方在于其内部会对资源的多次引用计数，这样尽管支持复制，但是可以精细的管理持有的资源。
需要注意的是shared_ptr没有release函数。

#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()
{
    shared_ptr<Test> sp3;
    {
        cout << "{" << endl;

        shared_ptr<Test> sp1 = make_shared<Test>("A");
        cout << "引用次数：" << sp1.use_count() << endl; // 1
        shared_ptr<Test> sp2(sp1); // 拷贝构造函数
        cout << "引用次数：" << sp1.use_count() << endl; // 2
        cout << "引用次数：" << sp2.use_count() << endl; // 2
        sp2.reset(new Test("B"));
        cout << "引用次数：" << sp1.use_count() << endl; // 1
        cout << "引用次数：" << sp2.use_count() << endl; // 1

        sp3 = sp1; // 赋值运算符
        cout << "引用次数:" << sp1.use_count() <<
                " " << sp3.use_count() << endl;

        cout << "}" << endl;
    }
    // 只有在计数清零的时候才会销毁持有的堆内存对象
    cout << "引用次数:" << sp3.use_count() << endl;
    cout << "主函数执行结束" << endl;
    return 0;
}

4.weak_ptr

1）weak_ptr主要是协助shared_ptr进行工作，因为是弱关系，所以在访问时不会影响引用计数
但是如果想要访问堆内存资源对象的功能时，需要用内置函数.lock()转换成shared_ptr才能
正常进行使用
2）但是weak_ptr的关联对象一旦被释放或者关联失效，weak_ptr就无法继续获得资源
所以weak_ptr增加了一个empired()函数，功能是监测管理的指针对象的时效性，一旦被释放或者关联失效，则返回true，反之则说明资源存在，可以继续使用。

#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()
{
    shared_ptr<Test> sp1 = make_shared<Test>("A");
    cout << sp1.use_count() << endl; // 1
    {
        weak_ptr<Test> wp1(sp1);
        weak_ptr<Test> wp2 = sp1;

        cout << sp1.use_count() << endl; // 1
        // weak_ptr → share_ptr
        shared_ptr<Test> sp2 = wp1.lock();
        cout << sp1.use_count() << endl; // 2
    }
    cout << sp1.use_count() << endl; // 1
    return 0;
}

时效性检测
weak_ptr增加了一个expired()函数来检测管理的指针对象的时效性。返回true，说明引用的资源已经不存在了，反之说明资源存在，这时候再使用lock函数。

5.四个指针的字节大小

在这里插入图片描述
因为shared_ptr和weak_ptr相对于前两者增加了计数引用,即多出一个32 位的数据空间，所以多4字节

不欺暗室__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 智能指针(unique_ptr, shared_ptr)的源码分析
哆啦咪~fo
10-14 3601
在博文https://blog.csdn.net/qq_27717921/article/details/82940519已经介绍了unique_ptr和shared_ptr的使用，但是这两类的智能指针是如何做到管理指针的呢？ shared_ptr 头文件 template &lt;typename T&gt; class SharedPointer { public: SharedPo...
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
C++ 智能指针
风间琉璃的博客
10-21 850
目录一、智能指针定义二、四种智能指针1.std::auto_ptr2.std::unique_ptr3.std::shared_ptr4.std::weak_ptr​智能指针：将指针对象模板化实现了类型的通用，构成智能指针。 实现智能指针时需要考虑以下三个方面的问题：RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、互斥量等等）的简单技术。 智能指针就是要模拟原生指针的行为，当将一个指针赋值给另一个指针时，目的就是
智能指针——shared_ptr的原理及仿写
saber520___的博客
09-14 75
【代码】智能指针——shared_ptr的原理及仿写。
【C++知识】智能指针——shared_ptr
qq_36417014的博客
09-09 362
智能指针 智能指针是一个模板类，封装了普通指针。通过在构造函数中初始化分配内存，在析构函数中释放内存，达到自己管理内存，不需要手动管理内存的效果。 shared_ptr：通过引用计数来实现对象是否被释放。当引用计数为0时，表示没有指针指向这块内存，析构函数可以去释放这块内存了。 自己实现： //引用计数类 class Counter{ public: int s; //shared_ptr引用计数 int w; //weak_ptr引用计数 Cou..
C++11智能指针shared_ptr介绍和辅助函数
长期更新Java自学笔记
09-06 842
做出一个像Java中垃圾回收器，并且可以运用到所有资源，heap内存和系统资源都可以使用的系统。std::shared_ptr就是C++11推出的解决方案shared_ptr实现了共享所有权(shared ownership)方式来管理资源对象，这意味没有一个特定的std::shared_ptr拥有资源对象。相反，这些指向同一个资源对象的std::shared_ptr相互协作来确保该资源对象在不需要的时候被析构基于共享所有权模式：多个指针能够同时指向同一个资源。
Red Panda c++
01-29
在实际开发中，C++程序员还需要了解如何有效地管理内存，使用智能指针（如unique_ptr、shared_ptr）来防止内存泄漏。同时，C++11及其后续版本引入了许多新特性，如右值引用、lambda表达式和自动类型推断（auto），...
C++设计新思维_C++_
10-01
7. 轻量级智能指针（smart pointers）：如`std::unique_ptr` 和 `std::shared_ptr`，它们是C++11引入的，用于管理对象的生命周期，防止内存泄漏，是现代C++编程中资源管理的重要工具。 8. 设计原则：C++设计新思维...
C++面试总结.zip
最新发布
01-20
面试中可能会涉及动态内存分配（new/delete）、智能指针（shared_ptr、unique_ptr、weak_ptr）的使用，以及内存泄漏的预防。理解RAII（Resource Acquisition Is Initialization）原则，能够有效避免内存管理中的问题...
C++的思考C++的思考C++的思考
05-10
最后，作者可能会讨论C++11及后续版本引入的新特性，如智能指针、右值引用、lambda表达式、自动类型推断（auto关键字）等，这些都极大地改善了C++的可读性和易用性，使其成为更现代的编程语言。 通过阅读《C++的...
C++智能指针实现（不用再担心你的内存泄露）
03-24
代码量，2.5KB，指针共享操作，自动在最后一个智能指针销毁时delete，不再产生内存泄露。内含简单使用范例。不支持管理数组。设有Debug版本的断言，确保智能空指针不被使用。 /* 智能指针类 不能用于数组，指针指向的数据必须是new出来的 不能创造该类的指针 不能将任意实体指针分别赋值给两个不同的智能指针（通过构造函数或者=） */
C++智能指针2——共享指针shared_ptr详解
xuyouqiang1987的博客
01-29 2万+
目录 简介 示例 代码 输出 创建 定义删除器 示例 处理数组 销毁其他资源 接口列表 隐式指针转换 比较运算符 获取删除器 别名构造函数 make_shared()和allocate_shared() 强制类型转换 线程安全的接口 使用错误 简介 共享指针shared_ptr是具有共享所有权语义的智能指针。 每当共享指针shared_ptr的最后一个所有者...
C++中的智能指针
pigff的博客
06-14 807
以下四个智能指针都是boost库中的 1.auto_ptr 管理权转移，带有缺陷的设计。尽量不要使用它 2.scoped_ptr 防拷贝，高效简洁。不需要拷贝/赋值，尽量使用它 3.shared_ptr 共享（引用计数）管理、支持赋值/拷贝。缺陷：循环使用（针对循环使用有weak_ptr). 4.weak_ptr辅助shared_ptr解决循环引用，不增加引用计数。 下面是关于auto_ptr的模
c++11 智能指针 （std::shared_ptr）（一）
qq_40788199的博客
09-08 4847
std::shared_ptr 是通过指针保持对象共享所有权的智能指针。多个 shared_ptr 对象可占有同一对象。下列情况之一出现时销毁对象并解分配其内存： 最后剩下的占有对象的 shared_ptr 被销毁； 最后剩下的占有对象的 shared_ptr 被通过 operator= 或 reset() 赋值为另一指针。 用 delete 表达式或在构造期间提供给 shared_ptr 的定制删除器销毁对象。
C++11中shared_ptr的使用
热门推荐
网络资源是无限的
08-13 8万+
C++11中shared_ptr的使用
c++智能指针用法
ljjjjjjjjjjj的博客
12-10 1570
智能指针一共有4个，分别是shared_ptr，unique_ptr，weak_ptr，auto_ptr，最后一个被弃用了，主要是前面三种。作用是自动回收内存，不需要是delete，原理是智能指针内部有个计数器，每当创建一次对象计数加一，销毁一次计数减一，当计数等于0时自动释放对象。
C++ - std::shared_ptr::reset
既然选择了远方 便只顾风雨兼程 - 永强
07-12 9558
C++ - std::shared_ptr::reset public member function - 公开成员函数 Defined in header <memory> - 定义于头文件 <memory> 1. std::shared_ptr::reset (1) void reset() noexcept; (2) template <class U> void reset (U* p); (3) template <class U, class D>
shared_ptr的reset()
枯树无花
09-23 2万+
shared_ptr的reset( )函数的作用是将引用计数减1，停止对指针的共享，除非引用计数为0，否则不会发生删除操作。
shared_ptr的一些尴尬
lujun-cc的专栏
05-28 2万+
shared_ptr在boost库中已经有多年了，C++11又为其正名，把他引入了STL库，放到了std的下面，可见其颇有用武之地；但是shared_ptr是万能的吗？有没有什么样的问题呢？本文并不说明shared_ptr的设计原理，也不是为了说明如何使用，只说一下在使用过程中的几点注意事项。 智能指针是万能良药？ 智能指针为解决资源泄漏，编写异常安全代码提供了一种解决方案，那么他
C++14风格指南：现代C++编程要点
例如，智能指针（smart pointers）如`std::unique_ptr`和`std::shared_ptr`成为了默认的选择，以替代原始指针，自动管理内存，减少内存泄漏的风险。 演讲还指出，对于每一个C++程序员来说，了解现代C++的这些简单...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值