C++11/14之STD::SHARED_PTR引用次数详解

最新推荐文章于 2022-12-22 21:19:08 发布
最新推荐文章于 2022-12-22 21:19:08 发布
阅读量317 收藏
点赞数
分类专栏： vc/c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012787710/article/details/126279188
版权

C++11/14之STD::SHARED_PTR引用次数详解

注意：

  1. 注意值参数和构造参数中copy导致引用加1
  2. 引用参数和move结合,原目标引用次数为0,新目标持有源目标次数

详细比较和分析如下

  1. c++中使用std::shared_ptr类型做为构造函数参数，并使用std::move()初始化成员变量。
#include <iostream>
#include <utility>
#include <memory>

class Base
{
public:
    // 值参数copy增加1， move导致源目标引用次数为0，次数转移为目标持有
    Base(std::shared_ptr<int> a, std::shared_ptr<int> b)
        : x{ std::move(a) }
        , y{ std::move(b) }
    {
        std::cout << "a->count=" << a.use_count() << std::endl; // 0
        std::cout << "b->count=" << b.use_count() << std::endl; // 0
    }

    void display()
    {
        std::cout << "member: x->count=" << x.use_count() << std::endl; //3
        std::cout << "member: y->count=" << y.use_count() << std::endl; //2
        std::cout << "--------------------------------" << std::endl;
    }
private:
    std::shared_ptr<int> x;
    std::shared_ptr<int> y;
};

int main(void)
{
    auto sp1 = std::make_shared<int>(111);
    std::cout << "sp1->count=" << sp1.use_count() << std::endl; //1
    decltype(sp1) sp2 = sp1;
    std::cout << "sp1->count=" << sp1.use_count() << std::endl; //2
    std::cout << "sp2->count=" << sp2.use_count() << std::endl; //2
    auto sp4 = std::make_shared<int>(444);
    std::cout << "sp4->count=" << sp4.use_count() << std::endl; //1
    Base b(sp1, sp4);
    b.display();

    std::cout << "sp1->count=" << sp1.use_count() << std::endl; //3
    std::cout << "sp2->count=" << sp2.use_count() << std::endl; //3
    std::cout << "sp4->count=" << sp4.use_count() << std::endl; //2

    return 0;
}
  1. c++中使用std::shared_ptr类型做为构造函数参数，并直接初始化成员变量。
#include <iostream>
#include <utility>
#include <memory>

class Base
{
public:
    // 值参数copy增加1，构造参数复制增加1，a,b 均增加2
    Base(std::shared_ptr<int> a, std::shared_ptr<int> b)
        : x{ a }
        , y{ b }
    {
        std::cout << "a->count=" << a.use_count() << std::endl; //4
        std::cout << "b->count=" << b.use_count() << std::endl; //3
    }

    void display()
    {
        // 构造函数执行完自动释放a,b引用，引用减去1
        std::cout << "member: x->count=" << x.use_count() << std::endl; //3
        std::cout << "member: y->count=" << y.use_count() << std::endl; //2
        std::cout << "--------------------------------" << std::endl;
    }
private:
    std::shared_ptr<int> x;
    std::shared_ptr<int> y;
};

int main(void)
{
    auto sp1 = std::make_shared<int>(111);
    std::cout << "sp1->count=" << sp1.use_count() << std::endl; //1
    decltype(sp1) sp2 = sp1;
    std::cout << "sp1->count=" << sp1.use_count() << std::endl; //2
    std::cout << "sp2->count=" << sp2.use_count() << std::endl; //2
    auto sp4 = std::make_shared<int>(444);
    std::cout << "sp4->count=" << sp4.use_count() << std::endl; //1
    Base b(sp1, sp4);
    b.display();
    std::cout << "sp1->count=" << sp1.use_count() << std::endl; //3
    std::cout << "sp2->count=" << sp2.use_count() << std::endl; //3
    std::cout << "sp4->count=" << sp4.use_count() << std::endl; //2

    return 0;
}
  1. c++中使用std::shared_ptr通过引用的方式做为构造函数参数，并使用std::move()初始化成员变量。
#include <iostream>
#include <utility>
#include <memory>

class Base
{
public:
      //引用参数不变，move导致源目标引用次数为0，次数转移为目标持有
      Base(std::shared_ptr<int>& a, std::shared_ptr<int>& b)
          : x{ std::move(a) }
          , y{ std::move(b) }
    {
        std::cout << "a->count=" << a.use_count() << std::endl; //0
        std::cout << "b->count=" << b.use_count() << std::endl; //0
    }

    void display()
    {
        std::cout << "member: x->count=" << x.use_count() << std::endl; //2
        std::cout << "member: y->count=" << y.use_count() << std::endl; //1
        std::cout << "--------------------------------" << std::endl;
    }
private:
    std::shared_ptr<int> x;
    std::shared_ptr<int> y;
};

int main(void)
{
    auto sp1 = std::make_shared<int>(111);
    std::cout << "sp1->count=" << sp1.use_count() << std::endl; //1
    decltype(sp1) sp2 = sp1;
    std::cout << "sp1->count=" << sp1.use_count() << std::endl; //2
    std::cout << "sp2->count=" << sp2.use_count() << std::endl; //2
    auto sp4 = std::make_shared<int>(444);
    std::cout << "sp4->count=" << sp4.use_count() << std::endl; //1
    Base b(sp1, sp4);
    b.display();
    std::cout << "sp1->count=" << sp1.use_count() << std::endl; //0
    std::cout << "sp2->count=" << sp2.use_count() << std::endl; //2  与x引用同一个参数
    std::cout << "sp4->count=" << sp4.use_count() << std::endl; //0

    return 0;
}
  1. c++中使用std::shared_ptr通过引用的方式做为构造函数参数，并直接初始化成员变量。
#include <iostream>
#include <utility>
#include <memory>

class Base
{
public:
    //引用 a,b 为sp1和sp4 次数 2,1
    Base(std::shared_ptr<int>& a, std::shared_ptr<int>& b)
        : x{ a }
        , y{ b }
    {
        //构造x,y 增加 1
        std::cout << "a->count=" << a.use_count() << std::endl; //3
        std::cout << "b->count=" << b.use_count() << std::endl; //2
    }

    void display()
    {
        std::cout << "member: x->count=" << x.use_count() << std::endl; //3
        std::cout << "member: y->count=" << y.use_count() << std::endl; //2
        std::cout << "--------------------------------" << std::endl;
    }
private:
    std::shared_ptr<int> x;
    std::shared_ptr<int> y;
};

int main(void)
{
    auto sp1 = std::make_shared<int>(111);
    std::cout << "sp1->count=" << sp1.use_count() << std::endl; //1
    decltype(sp1) sp2 = sp1;
    std::cout << "sp1->count=" << sp1.use_count() << std::endl; //2
    std::cout << "sp2->count=" << sp2.use_count() << std::endl; //2
    auto sp4 = std::make_shared<int>(444);
    std::cout << "sp4->count=" << sp4.use_count() << std::endl; //1
    Base b(sp1, sp4);
    b.display();
    // x,y 分别对应 sp1 sp4次数一致 3,2
    std::cout << "sp1->count=" << sp1.use_count() << std::endl;
    std::cout << "sp2->count=" << sp2.use_count() << std::endl;
    std::cout << "sp4->count=" << sp4.use_count() << std::endl;

    return 0;
}

参考

C++11/14之STD::SHARED_PTR作为引用参数，普通参数

骇客之技术
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++智能指针 shared_ptr引用计数分析
DU_YULIN的博客
09-10 3464
文章目录前言一、C++ 智能指针shared_ptr总结 前言 今天和人争论C++ 智能指针shared_ptr引用计数问题，然后代码实现验证，这里分享给大家。 一、C++ 智能指针shared_ptr shared_ptr智能指针是一个类，用于管理new 分配的对象，该智能指针类内部有一个保存引用计数的属性，通过这个属性来判断是否可以释放要管理的对象, 该判断是在智能指针类shared_ptr的析构函数中进行。当引用计数为0时，表示当前程序没有用到该管理对象的地方了，可以释放该管理对象了，即delet
C++引用计数
weixin_30316097的博客
11-08 105
简介 引用计数就是对一个对象记录其被引用的次数，其的引用计数可加可减，那什么时候加什么时候减呢？所以引用计数的重点在于在哪里加，在哪里减； 加： 减： 实现 // // Ref.hpp // Ref // // Created by George on 16/11/6. // Copyright © 2016年 George. All rights reserved. // #ifnde...
shared_ptr
Nex_Chin的专栏
12-16 1082
shared_ptr 头文件: "boost/shared_ptr.hpp" shared_ptr 可以从一个裸指针、另一个shared_ptr、一个std::auto_ptr、或者一个boost::weak_ptr构造。还可以传递第二个参数给shared_ptr的构造函数，它被称为删除器(deleter)。删除器稍后会被调用，来处理共享资源的释放。这对于管理那些不是用new分配也不是
C++ 简易string类实现（四）-自动操作引用次数
HappyKocola的博客
05-17 405
在 C++ 简易string类实现（三）-抽离引用计数中，RCObject class给了我们一个放置引用次数的空间，也给了我们一些member functions，用来操作引用次数.然而，这些函数的调用动作还是一定得由我们手动式地安插到其它class内.并且还是有劳String copy constructor和String assignment operator调用StringValue对象所提
C++11 std::shared_ptr总结与使用示例代码详解
08-19
C++11 std::shared_ptr总结与使用示例代码详解 std::shared_ptr是C++11中引入的一种智能指针，主要用于自动管理资源的生命周期。下面是std::shared_ptr的总结和使用示例代码详解： 一、智能指针的用途 std::...
浅析Boost智能指针:scoped_ptr shared_ptr weak_ptr
09-05
它类似于C++11中的`std::unique_ptr`，但不支持所有权转移。 #### 特点： 1. **非拷贝性**：`boost::scoped_ptr` 不支持拷贝构造函数和赋值运算符，这意味着它不能被复制或赋值给其他`boost::scoped_ptr`，确保了...
C++11 智能指针之shared_ptr代码详解
12-17
在C++11标准中，智能指针成为了内存管理的重要工具，旨在提供一种更加安全、自动化的内存管理机制。在三种主要的智能指针类型中，`shared_ptr` 是最常用的一种，它通过引用计数来实现对象的共享和自动释放。`shared_...
C++ unique_ptr weak_ptr shared_ptr auto_ptr智能指针.doc
07-23
shared_ptr 是 C++11 中引入的智能指针，它可以管理动态分配的内存，并允许多个实例共享同一块内存。shared_ptr 的机制是通过计数器管理引用同一个指针的指针实例对象的个数，实现多个对象共享同一块内存。 四、...
c++11之std::shared_ptr、std::weak_ptr的用法以及循环引用计数问题
endouver的博客
08-17 2566
c++11之std::shared_ptr的用法以及循环引用计数问题shared_ptr指针新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowcha...
C++智能指针shared_ptr的三种使用方式
程序猿老樊的博客
03-31 1万+
智能指针通常是指基于引用计数的智能指针，在c++11标准中就是std::shared_ptr。它的特点是如果可以安全的放入STL容器中。 有以下三种方式可以使用shared_ptr 1. 如果你的c++编程环境支持c++标准，那么可以直接使用 std::shared_ptr，它定义在memory文件中。 2. 如果你的c++实现支持 C++TR1库扩展，那么可以使用 std::tr1::sh
智能指针shared_ptr之引用计数
lucas1018的博客
12-22 2823
智能指针shared_ptr之引用计数
C++智能指针shared_ptr用法
weixin_40355471的博客
12-03 8703
C++，shared_ptr对象管理指针,shared_ptr提供的接口, shared_ptr初始化,构造函数初始化,std::make_shared 初始化,reset初始化,shared_ptr管理指针的构造和析构,shared_ptr获取原始指针,shared_ptr的线程安全,shared_ptr应用之enable_shared_from_this.
shared_ptr常用操作、计数、自定义删除器 [转]
baidu_41388533的博客
10-04 1505
https://blog.csdn.net/u012278016/article/details/108187828
5.3c++:shared_ptr的常用操作、计数、自定义删除器等（转载）
qq_41543888的博客
05-17 3517
shared_ptr 引用计数的增加和减少 共享式：引用计数，每一个 shared_ptr的拷贝都指向相同的内存（对象），只有最后一个指向该对象的shared_ptr指针不需要再指向该对象的时候，才会析构对象。 1.1引用计数的增加 每个shared_ptr都会记录有多少个其他的shared_ptr指向相同的对象 auto p6 = make_shared<int> ...
C++智能指针详解：shared_ptr
热门推荐
feikudai8460的博客
12-19 1万+
C++没有内存回收机制，每次程序员new出来的对象需要手动delete，流程复杂时可能会漏掉delete，导致内存泄漏。于是C++引入智能指针，可用于动态资源管理，资源即对象的管理策略。 使用 raw pointer 管理动态内存时，经常会遇到这样的问题： 忘记delete内存，造成内存泄露。 出现异常时，不会执行delete，造成内存泄露。 下面的代码解释了，当一个操作发生异常时，会导致delete不会被执行： void func() { auto ptr = new Widget;
C++基础 - 智能指针 shared_ptr 的引用计数
一只羊
07-20 3203
智能指针shared_ptr的引用计数，详见代码及说明 // shared_ptr的几种初始化方式 shared_ptr<int> p1; // null shared_ptr<string> p2 = make_shared<string>(); // 非null, 调用string默认构造函数 if(p2 && p2->empty()) { *p2 = "hello world"; }
c++ shared_ptr 按引用传参不增加引用计数
鸟哥的博客
03-20 2731
//by 鸟哥 演示 shared_ptr 不增加引用计数的情况 //有疑问请留言或加群 1032082534 #include <iostream> #include <memory> using namespace std; void f(shared_ptr<int>& sp){ cout<<"按引用传参不增加引用计数："...
std::shared_ptr 和 std::weak_ptr引用计数的循环引用问题
Cross
06-28 1182
shared维护了一个指向control block的指针，control block内部包含了智能指针对象的引用个数。weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象. 进行该对象的内存管理的是那个强引用的 shared_ptr. weak_ptr只是提供了对管理对象的一个访问手段. 　　weak_ptr 设计的目的是为配合 shared_pt...
std::shared_ptr 和 std::make_shared 使用详解
最新发布
09-13
std::shared_ptr 是 C++11 中引入的智能指针，它用于管理动态分配的资源。它提供了一种简单的方式来实现动态内存的分配和释放，同时避免了内存泄漏和悬挂指针的问题。 std::make_shared 是一个模板函数，用于创建 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

骇客之技术

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

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

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

打赏作者

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

抵扣说明：

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

余额充值