目录
一、 引言
二、 代码实现
2.1 模拟实现shared_ptr
2.2 测试用例
三、 潜在问题分析
你可能还需要了解模拟实现C++标准库中的auto_ptr
一、 引言
与auto_ptr大同小异，shared_ptr也是一个类。可以实现多个指针指向同一个对象（引用计数）。发生拷贝的话都指向相同的内存。
每使用一次，内部引用计数加1；
每析构一次，内部引用计数减1,；
引用计数减为0时，自动释放原生指针所指向的内存。
二、 代码实现
2.1 模拟实现shared_ptr
命名说明：为了和boost库提供的智能指针shared_ptr区分开，我将模拟实现的指针命名为mshared_ptr（m是my的简写）。
难点一、我们知道，boost库中提供的shared_ptr的核心就是引用计数，实现的方法不尽相同，只要能达到目的就可以了。在这里，我采用静态map表的方式来实现。
static map<T*, int> _map; //静态数据成员需要在类外进行初始化
如何理解这种操作？map表建立了原生指针T* 和次数一个映射。 如图1所示，如果有四个mshared_ptr（自主实现）类型的变量同时指向一块堆内存，map表中就会建立原生指针_ptr和4之间的一个映射。如果有更多的变量指向该块堆内存或者A、B、C、D其中有任何一个变量析构了，都会引起引用计数的变化。
图1 map表简要说明
难点二、 为什么成员运算符（俗称箭头）的重载返回类型是原生指针的类型？这一点在模拟实现C++标准库中的auto_ptr已经讨论过了。在这里再次讨论也无妨！mshared_ptr名为指针，实际上是类。对一个类采用成员运算符重载，返回值很自然的就是类中的成员了。
template<typename T>
T* mshared_ptr<T>::operator->() //成员运算符重载
{
return _ptr;
}
难点三、 引用计数是如何实现按需变化的？如下代码所示：if语句一定会进入，是否执行还得两说！if语句一经进入，引用计数就自减1了，在决定释放内存之前，万万牢记：不要对NULL指针进行操作，这就是if语句后半部分存在的意义。这小段代码在析构函数和赋值运算符重载中都出现了。值得注意一下。
if (--_map[_ptr] <= 0 && NULL != _ptr)
{
delete _ptr;
_ptr = NULL;
_map.erase(_ptr);
}
完整代码段：
#include<iostream>
using namespace std;
#include<map>
template<typename T>
class mshared_ptr
{
public:
mshared_ptr(T *ptr = NULL); //构造方法
~mshared_ptr(); //析构方法
mshared_ptr(mshared_ptr<T> &src); //拷贝构造
mshared_ptr& operator = (mshared_ptr<T> &src); //赋值运算符重载
T& operator*(); //解引用运算符重载
T* operator->(); //成员运算符重载
private:
T *_ptr;
static map<T*, int> _map; //静态数据成员需要在类外进行初始化
};
template<typename T>
map<T*, int> mshared_ptr<T>::_map;
template<typename T>
mshared_ptr<T>::mshared_ptr(T *ptr) //构造方法
{
cout << "mshared_ptr的构造方法正被调用！" << endl;
_ptr = ptr;
_map.insert(make_pair(_ptr, 1));
}
template<typename T>
mshared_ptr<T>::~mshared_ptr() //析构方法
{
cout << "mshared_ptr的析构方法正被调用！" << endl;
if (--_map[_ptr] <= 0 && NULL != _ptr)
{
delete _ptr;
_ptr = NULL;
_map.erase(_ptr);
}
}
template<typename T>
mshared_ptr<T>::mshared_ptr(mshared_ptr<T> &src) //拷贝构造
{
_ptr = src._ptr;
_map[_ptr]++;
}
template<typename T>
mshared_ptr<T>& mshared_ptr<T>::operator=(mshared_ptr<T> &src) //赋值运算符重载
{
if (_ptr == src._ptr)
{
return *this;
}
if (--_map[_ptr] <= 0 && NULL != _ptr)
{
delete _ptr;
_ptr = NULL;
_map.erase(_ptr);
}
_ptr = src._ptr;
_map[_ptr]++;
return *this;
}
template<typename T>
T& mshared_ptr<T>::operator*() //解引用运算符重载
{
return *_ptr;
}
template<typename T>
T* mshared_ptr<T>::operator->() //成员运算符重载
{
return _ptr;
}
2.2 测试用例
int main()
{
int *p = new int(10);
mshared_ptr<int>mshared_p1(p);
mshared_ptr<int>mshared_p2(new int(20));
cout << *mshared_p1 << endl;
cout << *mshared_p2 << endl;
system("pause");
return 0;
}
图2 VS2017运行结果
三、 潜在问题分析
在多线程环境下，引用计数可能会出错是不可避免的。但是通过加锁就能解决这个问题。本篇博客的关注点不在于多线程的环境下运行，故而未曾加锁。有一个问题，即使是boost库中的shared_ptr不可避免，那就是——循环引用（交叉引用）导致内存泄漏。现说明如下：
图3 循环引用示意图
mshared_ptr 利用引用计数来决定是否释放堆区的内存。如果存在循环引用的话，引用计数到最后还是会降不下去。如图3所示，类A只有成员_ptr_B，类B只有成员_ptr_A，如果发生上述情况，在ptr_A析构的时候，仅仅会将引用计数减1而不真正释放其所指向的内存；在ptr_B析构的时候也一样，究其根源，是因为类内的指针也占用了引用计数。
class B; //同文件，从上至下编译，故而需要告诉类A——类B确实存在
class A
{
public:
mshared_ptr<B>_ptr_B;
};
class B
{
public:
mshared_ptr<A>_ptr_A;
};
int main()
{
mshared_ptr<A>ptr_A(new A);
mshared_ptr<B>ptr_B(new B);
ptr_A->_ptr_B = ptr_B;
ptr_B->_ptr_A = ptr_A;
return 0;
}
图4 VS2017下验证示意图
从运行结果我们可以看到，ptr_A和ptr_B都已被析构，但是类内的指针没有被析构，这就是导致内存泄漏的罪魁祸首。如何解决这个问题，我们需要使用mshared_ptr的好搭档——mweak_ptr。模拟实现boost库中的weak_ptr 。
————————————————
版权声明：本文为CSDN博主「楚楚可薇」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41822235/article/details/82934681