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

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的助手，是弱指针，可用于解除环状引用，但不支持原生指针获取以及->和*操作。