智能指针仿真-003-共享智能指针

最新推荐文章于 2020-11-24 20:56:31 发布
最新推荐文章于 2020-11-24 20:56:31 发布
阅读量729 收藏
点赞数
分类专栏： C++技术总结 基础编程 文章标签： 智能指针 shared-ptr weak-ptr
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/segen_jaa/article/details/48597425
版权

1. 概述
本篇对共享所有权的智能指针进行仿真。
仿真指针主要有：boost/c++ 11 tr1中的shared_ptr、weak_ptr。
boost与c++ 11 tr1的关系这里稍微做一下类比，shared_ptr在boost中时可以认为是储君（准标准），进入到了tr1之后就正名了就算正式登基了是完全标准的了。

2. this指针的探讨
this指针是编译器默认生成到成员函数中的，类型为T* const this。
例如写一个简单的成员函数。

class A
{
public:
    void func(){}
};

编译器处理起来如下。

void func(A* const this);

接下来要思考的问题就是。
1) this指针可以删除吗？
2) 执行删除操作有引发哪些问题？

2.1. delete this源码
成员函数内进行delete this操作源码如下。

class CTest
{
public:
    CTest() : m_nVal(0){}
    ~CTest() {}

    /// @brief 释放自身内存
    void Release() {delete this;}

private:
    int m_nVal;///< 测试成员变量
};

2.2. delete this栈检测
对于栈分配，进行delete检测。

void TestStackDelete()
{
    /// @brief 检测栈释放
    CTest test;
    test.Release();
}

int _tmain(int argc, _TCHAR* argv[])
{
    TestStackDelete();
    return 0;
}

运行程序会报错。

2.3. delete this堆检测
对于堆分配，进行delete检测。

void TestHeapDelete()
{
    /// @brief 检测堆释放
    CTest* pTest = new CTest;
    pTest->Release();
}

int _tmain(int argc, _TCHAR* argv[])
{
    TestHeapDelete();
    return 0;
}

运行程序后释放内存正常。

2.4. delete this总结
对delete this做下总结。
1) 对栈上分配的空间则不要调用。
2) 可以采用这种方式来释放堆中分配内存。
3) 调用对应接口后，指针将变为野指针，不可再进行后续操作。

3. shared_ptr仿真

3.1. shared_ptr相关问题
带着如下问题来做仿真实现。
1) shared_ptr实现原理？
2) shared_ptr是否就意味着一统天下？
3) shared_ptr使用中的坑？

3.2. 引用计数类仿真
Shared_ptr中采用引用计数来进行所有权共享，当引用计数为0时进行资源释放。首先进行引用计数类仿真MyRefCount.h。

#pragma once

/// @brief 引用计数类
template<class _Ty>
class CMyRefCount
{
public:
    CMyRefCount(_Ty *_Px)
        : m_nUses(1)
        , m_nWeaks(1)
        , _Ptr(_Px)
    {}

    /// @brief 增加强引用计数
    void _Incref() {++m_nUses;}
    /// @brief 增加弱引用计数
    void _Incwref() {++m_nWeaks;}
    /// @brief 减少强引用计数
    void _Decref()
    {
        --m_nUses;
        if (0 == m_nUses)
        {
            _Destroy();
            _Decwref();
        }
    }
    /// @brief 减少弱引用计数
    void _Decwref()
    {
        --m_nWeaks;
        if (0 == m_nWeaks)
        {
            _Delete_this();
        }
    }
    /// @brief 获取强引用计数
    long _Use_count() const {return (m_nUses);}
    /// @brief 指针是否已释放
    bool _Expired() const {return (0==m_nUses);}

private:
    void _Destroy() {delete _Ptr;}
    void _Delete_this() {delete this;}

private:
    long m_nUses;///< 强引用次数
    long m_nWeaks;///< 弱引用次数
    _Ty * _Ptr;
};

3.3. 共享指针基类仿真
Weak_ptr和shared_ptr的共用基类进行仿真MyPtrBase.h。

#pragma once
#include "MyRefCount.h"

/// @brief shared_ptr/weak_ptr基类
template<class _Ty>
class CMyPtrBase
{
    typedef CMyPtrBase<_Ty> _Myt;

public:
    /// @brief 获取强引用计数
    long use_count() const
    {
        if (NULL == _Rep) {return 0;}
        return (_Rep->_Use_count());
    }

protected:
    CMyPtrBase()
        : _Ptr(nullptr)
        , _Rep(nullptr)
    {}
    /// @brief 指针是否已释放
    bool _Expired() const
    {
        if (NULL == _Rep) {return true;}
        return (_Rep->_Expired());
    }
    /// @brief 获取原生指针
    _Ty *_Get() const {return (_Ptr);}
    /// @brief 减少强引用计数
    void _Decref()
    {
        if (nullptr == _Rep) {return;}
        _Rep->_Decref();
    }
    /// @brief 重置资源强引用
    void _Reset(const _Myt& _Other)
    {
        _Reset(_Other._Ptr, _Other._Rep, false);
    }
    void _Reset(_Ty *_Other_ptr, CMyRefCount<_Ty> *_Other_rep, bool bInit)
    {
        /// @brief 初次赋值则不做增加操作
        if (!bInit)
        {
            if (_Other_rep != nullptr) {_Other_rep->_Incref();}///< other强引用增加
        }
        if (_Rep != nullptr) {_Rep->_Decref();}///< this强引用减少
        _Rep = _Other_rep;
        _Ptr = _Other_ptr;
    }
    /// @brief 减少弱引用计数
    void _Decwref()
    {
        if (nullptr == _Rep) {return;}
        _Rep->_Decwref();
    }
    /// @brief 重置资源弱引用
    void _Resetw(const _Myt& _Other)
    {
        _Resetw(_Other._Ptr, _Other._Rep);
    }
    void _Resetw(_Ty *_Other_ptr, CMyRefCount<_Ty> *_Other_rep)
    {
        if (_Other_rep != nullptr) {_Other_rep->_Incwref();}///< other弱引用增加
        if (_Rep != nullptr) {_Rep->_Decwref();}///< this弱引用减少
        _Rep = _Other_rep;
        _Ptr = _Other_ptr;
    }

private:
    _Ty *_Ptr; ///< 持有指针
    CMyRefCount<_Ty> *_Rep; ///< 引用计数
};

3.4. weak_ptr及shared_ptr仿真源码
对应实现类MySharedPtr.h。

#pragma once
#include "MyPtrBase.h"

template<class _Ty>
class CMyWeakPtr;
template<class _Ty>
class CMySharedPtr;

template<class _Ty>
class CMySharedPtr : public CMyPtrBase<_Ty>
{
public:
    typedef CMySharedPtr<_Ty> _Myt;

    /// @brief 默认构造函数
    CMySharedPtr() {}
    /// @brief 析构函数中释放资源
    ~CMySharedPtr()
    {
        this->_Decref();
    }
    /// @brief 显示声明传值构造函数
    explicit CMySharedPtr(_Ty *_Px)
    {
        this->_Reset(_Px, new CMyRefCount<_Ty>(_Px), true);
    }
    /// @brief 拷贝构造函数
    CMySharedPtr(const _Myt& _Other)
    {
        this->_Reset(_Other);
    }
    /// @brief 赋值操作符
    _Myt& operator=(const _Myt& _Other)
    {
        this->_Reset(_Other);
        return (*this);
    }
    /// @brief 支持weak_ptr复制
    /// 不支持weak_ptr赋值，需要通过lock来转获取share_ptr
    explicit CMySharedPtr(const CMyWeakPtr<_Ty>& _Other)
    {
        this->_Reset(_Other);
    }
    /// @brief 重置
    void reset()
    {
        this->_Reset(nullptr, nullptr, false);
    }
    /// @brief 获取原生指针
    _Ty *get() const {return (this->_Get());}
    /// @brief 仿真指针操作
    _Ty *operator->() const {   return (this->_Get());}
    _Ty &operator*() const {    return (*this->_Get());}
    /// @brief 是否唯一持有资源
    bool unique() const {return (this->use_count() == 1);}
};

template<class _Ty>
class CMyWeakPtr : public CMyPtrBase<_Ty>
{
    typedef CMyWeakPtr<_Ty> _Myt;

public:
    CMyWeakPtr() {}
    ~CMyWeakPtr() {this->_Decwref();}

    explicit CMyWeakPtr(const _Myt& _Other) {this->_Resetw(_Other);}
    CMyWeakPtr& operator=(const _Myt& _Other)
    {
        this->_Resetw(_Other);
        return (*this);
    }
    /// @brief shared_ptr支持
    explicit CMyWeakPtr(const CMySharedPtr<_Ty>& _Other) {this->_Resetw(_Other);}
    CMyWeakPtr& operator=(const CMySharedPtr<_Ty>& _Other)
    {
        this->_Resetw(_Other);
        return (*this);
    }
    /// @brief 重置
    void reset() {this->_Resetw(nullptr, nullptr, false);}
    /// @brief 资源释放还存在
    bool expired() const {return (this->_Expired());}
    /// @brief 转化为shared_ptr
    CMySharedPtr<_Ty> lock() const
    {
        return (CMySharedPtr<_Ty>(*this));
    }
};

3.5. 仿真指针使用源码
对指针进行使用。

#include "stdafx.h"
#include "MySharedPtr.h"
#include <iostream>

class CTest
{
public:
    CTest() {std::cout<<"CTest()"<<std::endl;}
    ~CTest() {std::cout<<"~CTest()"<<std::endl;}
    void test_print() {std::cout<<"test_print()"<<std::endl;}
};

int _tmain(int argc, _TCHAR* argv[])
{
    CMySharedPtr<CTest> t1(new CTest);
    /// @brief 原生指针检测
    t1->test_print();
    (*t1).test_print();
    std::cout<<t1.use_count()<<std::endl;
    {
        /// @brief 检测复制
        CMySharedPtr<CTest> t2(t1);
        std::cout<<t1.use_count()<<std::endl;
    }
    std::cout<<t1.use_count()<<std::endl;
    {
        /// @brief 检测赋值
        CMySharedPtr<CTest> t3;
        t3 = t1;
        std::cout<<t1.use_count()<<std::endl;
    }
    std::cout<<t1.use_count()<<std::endl;
    {
        /// @brief 检测weak_ptr
        CMyWeakPtr<CTest> w1(t1);///< weak_ptr不会增加引用计数
        std::cout<<t1.use_count()<<std::endl;
        CMySharedPtr<CTest> t4(w1);///< 通过构造函数获取weak_ptr引用指针
        std::cout<<t1.use_count()<<std::endl;
        CMySharedPtr<CTest> t5;
        //t5 = w1;///< 检测weak_ptr直接赋值会编译失败
        t5 = w1.lock();///< 通过lock获取weak_ptr引用指针
        std::cout<<t1.use_count()<<std::endl;
    }

    return 0;
}

输出结果：

CTest()
test_print()
test_print()
1
2
1
2
1
1
2
3
~CTest()

3.6. shared_ptr环状引用示例
shared_ptr出现环状引用的话将出现资源泄漏。采用自引用示例来检测。

#include "stdafx.h"
#include "MySharedPtr.h"
#include <iostream>

class CSelfRefTest
{
public:
    CSelfRefTest() {std::cout<<"CSelfRefTest()"<<std::endl;}
    ~CSelfRefTest() {std::cout<<"~CSelfRefTest()"<<std::endl;}

    CMySharedPtr<CSelfRefTest> m_pTest;
};

int _tmain(int argc, _TCHAR* argv[])
{
    /// @brief shared_ptr产生环形引用时将出现资源泄漏情况
    /// 采用自引用示例来说明
    CMySharedPtr<CSelfRefTest> p1(new CSelfRefTest);
    std::cout<<p1.use_count()<<std::endl;
    p1->m_pTest = p1;///< 进行自引用操作
    std::cout<<p1.use_count()<<std::endl;
    return 0;
}

运行结果：

CSelfRefTest()
1
2

3.7. weak_ptr解决环状引用
weak_ptr引用不会引起计数增加，可用来破环状引用。

#include "MySharedPtr.h"
#include <iostream>

class CSelfRefTest
{
public:
    CSelfRefTest() {std::cout<<"CSelfRefTest()"<<std::endl;}
    ~CSelfRefTest() {std::cout<<"~CSelfRefTest()"<<std::endl;}

    CMyWeakPtr<CSelfRefTest> m_pTest;
};

int _tmain(int argc, _TCHAR* argv[])
{
    /// @brief shared_ptr产生环形引用时将出现资源泄漏情况
    /// 采用weak_ptr来解决该问题
    CMySharedPtr<CSelfRefTest> p1(new CSelfRefTest);
    std::cout<<p1.use_count()<<std::endl;
    p1->m_pTest = p1;///< 进行自引用操作
    std::cout<<p1.use_count()<<std::endl;
    return 0;
}

运行结果：

CSelfRefTest()
1
1
~CSelfRefTest()

3.8. shared_ptr总结
通过仿真源码，对shared_ptr总结如下。
1) 共享型智能指针通过引用计数方式来实现所有权共享，但同时增加了程序复杂度和运行性能。
2) 避免出现环状引用，这将会引起资源泄漏。
3) weak_ptr是shared_ptr的助手，是弱指针，可用于解除环状引用，但不支持原生指针获取以及->和*操作。

segen_jaa
关注
专栏目录
人工智能专业数据结构课程论文-《浅谈递归算法及其在人工智能方面的应用》
m0_64198455的博客
12-21 895
随着课程的推进，我们进入了特殊线性表——栈与队列的学习。而栈有一个重要应用是在程序设计语言中实现递归。递归是算法设计中常用的手段，它通常可把一个大型复杂问题的描述和求解变得简洁和清晰。因此递归算法常常比非递归算法更易设计，尤其是当问题本身或所涉及的数据结构是递归定义的时候，使用递归方法更加合适。除此之外，递归在人工智能方面也有着广泛的应用，如深度学习领域的递归神经网络、人工智能分支之一人工生命。人工智能的本质其实就是算法智能。总之，递归算法在很多领域都有显著体现和重要应用。
C/C++指针&智能指针二
最新发布
weixin_73497355的博客
07-14 795
C++智能指针是为了解决原始指针可能导致的内存泄漏、悬挂指针等问题而引入的自动资源管理工具，主要包括`std::unique_ptr`、`std::shared_ptr` 和 `std::weak_ptr`。
C++11里shared_ptr源码剖析
帅东's Blog
10-11 2435
很多人不知道引用计数放在哪，昨天为止我也不知道，O(∩_∩)O哈哈~A *a = new A; shared_ptr<A> sp(a);上面代码发生了什么呢？ 进入shared_ptr的构造函数template<class _Ux> explicit shared_ptr(_Ux *_Px){ _Resetp0(_Px, new _Ref_count<_Ux>(_Px));
从源码理解智能指针（二）—— shared_ptr、weak_ptr
HerofH_的博客
09-24 1万+
目录 计数器 _Ref_count _Ref_count_del _Ref_count_del_alloc _Ptr_base _Ptr_base的成员变量 构造函数 赋值重载 获取引用计数 减少引用计数 _Reset函数 _Resetw函数 shared_ptr 构造函数 无参构造 用一般参数构造 用完整对象构造 移动构造 析构函数 赋值重载 reset...
智能指针原理剖析（二）：shared_ptr、weak_ptr
weixin_49199646的博客
11-24 2190
通过常规指针管理动态内存的难点及缺点： （1）忘记释放动态内存： 使用new/malloc分配动态内存时，需要使用delete/free手动释放内存，但程序员容易忘记释放内存，从而产生内存泄露； （2）动态内存释放时机不对： 在尚有指针引用内存的情况下，程序员释放了内存，从而产生空悬指针。典型的案例就是：假设在多线程编程中，线程A、B中分别有指针p1、p2指向对象object，若某个时刻线程A通过p1将object销毁了（释放了object占有的内存），那么线程B中的p2引用object就会产生内存错误。
四种智能指针的用法和原理
心之所向，一如既往
04-04 2万+
智能指针共分为4种，即boost库中的auto_ptr、scoped_ptr、shared_ptr、weak_ptr。 　　智能指针的作用是管理一个指针，因为存在以下这种情况：申请的空间在函数结束时忘记释放，造成内存泄漏。所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。 　　操作的方法：在构造函数时，将类外需要管理的指针传进去，可以给个空的缺省值，然后重载“->”
智能指针
chewbee的专栏
09-26 303
智能指针 智能指针 简介 强指针sp 弱指针wp 重要函数实现 总结 1.简介1.指针问题的常见来源： 指针没有初始化 new了对象后没有及时delete 野指针 通过delete释放了对象，但没有将指针置空。 header 1 header 2 row 1 col 1 row 1 col 2 row 2 col 1 row 2 col 2 2.如何设计一个智能指针考虑的因素：
risc-v仿真器
02-15
1. **内存安全**：Rust 的所有权和生命周期系统确保了在编写代码时消除空指针异常、数据竞争和其他内存错误，这对于构建复杂的系统如仿真器至关重要。 2. **高性能**：Rust 直接生成机器码，可以与 C 和 C++ 竞争，...
"开源RISC-V评估平台中高效的基于VP的自适应仿真
Journal of Systems Architecture 116（2021）102135在开源RISC-V评估平台中使用虚拟原型进行...VP应提供高仿真性能，同时提高产量 准确的结果，这是两个相互矛盾的要求。为了解决这个问题，我们提出了一个高效的基于V
智能家居用单片机实现
03-26
- **分时操作系统**：一种允许多个用户通过网络共享同一主机资源的操作系统。它将CPU的时间划分为多个相等的时间片，轮流分配给不同的用户或进程。 #### 二、单片机在智能家居中的应用 - 在智能家居系统中，单片机...
2017年国际期刊完整文章：结构化覆盖网络的智能预测稳定模型的仿真结果
工程科学与技术，国际期刊20（2017）310完整文章结构化覆盖网络Ramanpreet Kaura，b，RamanpreetKaur a，Amrit Lal Sangala，Krishan Kumarca印度旁遮普邦贾朗达尔国家理工学院计算机科学与工程系b印度喜马偕尔邦索...
rep()函数简介
weixin_30617737的博客
08-04 8723
rep()函数：重复 rep(x,...) rep.int(x,times) rep_len(x,length.out) ·x：一个向量(vector),一个因子(factor),一个POSIXct或POSIXlt或Date对象(object)... ·...：更多其他的选项，可能有如下的： ·times：必为非负整数，负数或NA是错误的。每一个向量重复的次数。 ...
区块链技术之数字签名简介
TuxedoLinux的博客
12-05 2464
区块链技术之数字签名简介   区块链比特币中利用数字签名来保证数据在整个系统中不可篡改，并保证交易双方的身份真实可靠。数字签名使用了非对称加密技术和数字摘要技术，保证了数据在传输过程中的完整性、发送者身份真实不可假冒。非对称加密技术会产生一个公钥（publickey）和一个私钥（privatekey），公钥和私钥是一对，私钥保存在所有者手中，需要对外人保密不可让外人知道，公钥可以向其他信息接收方...
std::shared_ptr析构过程剖析
ypy9323的博客
07-22 3573
上篇文章介绍了shared_ptr对象构造，这篇文章记录其析构过程。     ~shared_ptr() _NOEXCEPT {    // release resource     this-&gt;_Decref(); //【1】 } //[1] void _Decref() {    // decrement reference count if (_Rep != 0)     _Rep-...
标准库里的weak_ptr如何解决循环引用所带来的问题
persistence_s的博客
04-04 2655
#include #include #include using namespace std; templateclass T> class Node { public: Node(T num) :value(num) { } ~Node() { cout "~Node()" << endl; } weak_
C++使用SQLite步骤及示例
热门推荐
Segen_Jaa的专栏
09-03 5万+
C++使用SQLite步骤及示例 开发环境：Windows XP+VS2005。 开发语言：C++。 1、 下载sqlite文件。 下载网址：http://www.sqlite.org/download.html。 SQLite版本为SQLite 3.7.13，相关文件如下。 sqlite-dll-win32-x86-3071300.zip：包含sqlite3.def、sq
Eclipse+CXF框架开发Web服务实战
Segen_Jaa的专栏
10-22 2万+
CXF开发Web服务，服务端与客户端实例。
指针式仪表视频监测识别：基于颜色与形状特征的算法
随着计算机网络技术的进步，视频监控已从模拟系统转向数字系统，后者具有传输质量高、抗干扰能力强、网络资源共享、扩容便捷、存储数字化等优势。然而，对于指针式仪表的监测，传统的基于Hough变换的形状提取方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值