C++ 智能指针shared_ptr原理与自定义实现

C++的智能指针，让码农们不再new一个对象，就要考虑什么时候调用delete，真的是香。
那么，既然香，它的原理是啥呢？根据其头文件，这里实现一个简化版的智能指针，更容易理解其原理。

智能指针shared_ptr，原理是，做引用计数，多一个引用就加1，少一个引用，就减去1，当引用计数为0，则认为没有人用了，就主动调用delete，完成对象释放。

直接上带码，带码中加了很多注释。涉及2个文件:

SharedPtr.h，即智能指针的头文件

#include<iostream>
#include<mutex>
#include<thread>
using namespace std;

/**
 * 智能指针，基于
 * 类模板, 虚拟类型名为T
 * */
template<class T>
class SharePtr {
public:
	SharePtr(T* ptr = nullptr)//初始化模板类对象，把托管对象的指针T带进来
		:_pPtr(ptr)//参数初始化
		, _pRefCount(new int(1))
		, _pMutex(new mutex)
	{
		std::cout << "SharePtr construct...， origin init" << std::endl;
	}
	~SharePtr()
	{
        std::cout << "SharePtr destruct..." << std::endl;
		release();
	}

	SharePtr(const SharePtr<T>& sp)
		:_pPtr(sp._pPtr)
		, _pRefCount(sp._pRefCount)
		, _pMutex(sp._pMutex)
	{
		std::cout << "SharePtr construct...， copy other sharePtr" << std::endl;
		addRefCount();
	}

	SharePtr<T>& operator=(const SharePtr<T>& sp)//重载 赋值运算符=
	{
        std::cout << "operator=" << std::endl;

		if (_pPtr != sp._pPtr) {
			std::cout << "operator=， will call release" << std::endl;
			// 释放管理的旧资源
			release();
			// 共享管理新对象的资源，并增加引用计数
			_pPtr = sp._pPtr;
			_pRefCount = sp._pRefCount;
			_pMutex = sp._pMutex;
			addRefCount();
		}
		return *this;
	}

	T& operator*() {//重载运算符*
		return *_pPtr;
	}

	T* operator->() {//重载运算符->，也就是_pPtr指向啥, 本模板类也指向啥
		std::cout << "operator ->" << std::endl;
		return _pPtr;
	}

	T* Get() {//获取托管对象的指针
		return _pPtr;
	}


private:

	void addRefCount() {//计数器加1
		_pMutex->lock();
		++(*_pRefCount);
        std::cout << "addRefCount, now ref count " << (*_pRefCount) << std::endl;
		_pMutex->unlock();
	}

	void release() {计数器加1
        std::cout << "release, current _pRefCount " <<  (*_pRefCount) << std::endl;

		bool deleteflag = false;
		_pMutex->lock();
		if (--(*_pRefCount) == 0)
		{
            std::cout << "will delete  _pPtr " << std::endl;
			delete _pRefCount;
			delete _pPtr;
			deleteflag = true;
		}
		_pMutex->unlock();
		if (deleteflag == true)
			delete _pMutex;
	}
private:
	int *_pRefCount;//引用计数
	T* _pPtr;//指向内容对象的指针
	mutex* _pMutex;//锁
};

main.cpp，测试的binary

#include "SharedPtr.h"

/**
 * 简单的类，准备用于被智能指针使用
 * */
class Test {
public:
	Test() {
		std::cout << "Test class construct" << std::endl;
	}
	~Test() {
		std::cout << "Test class destruct" << std::endl;
	}

	void printSomething() {
		std::cout << "Test printSomething" << std::endl;
	}
};

void doSomeTest(SharePtr<Test> pTest) {
	std::cout << "doSomeTest call" << std::endl;
	SharePtr<Test> pInnerTest = pTest;//相当于SharePtr<Test> pInnerTest(pTest), 这种写法，不会用到operator=
	
	std::cout << "will make an emptyPtr" << std::endl;
	SharePtr<Test> pInnerTest2;//当这样写，和java不一样的是，会实例话一个类模板的对象, 可以看打印日志来确认，当然了
	std::cout << "will set pInnerTest2" << std::endl;
	pInnerTest2 = pTest;//这种先建立变量，再赋值的写法，才会用到赋值运算符=

	pInnerTest->printSomething();//当这个函数执行结束，pTest和pInnerTest的生命周期就会结束，会调用析构

	std::cout << "will make one test" << std::endl;
	Test test;//这两句测试想说明的是，和Java不同，在函数内部声明一个类引用，就会初始化一个对象，不过是栈上分配，函数结束，就会释放
	test.printSomething();

}

int main(int argc, char* argv[]) {
	//Test* test(new Test());
	std::cout << "main start, will init SharePtr" << std::endl;

	SharePtr<Test> originPtr(new Test());

	std::cout << "will call doSomeTest" << std::endl;

	doSomeTest(originPtr);

	std::cout << "main end" << std::endl;

	return 0;
}

如何自己运行

在Ubuntu下，将上面2个文件，放到一个目录里，执行
g++ main.cpp -o out

就会生成out的一个可执行程序，然后执行：
./out

日志打印：

main start, will init SharePtr
Test class construct
SharePtr construct...， origin init
will call doSomeTest
SharePtr construct...， copy other sharePtr
addRefCount, now ref count 2
doSomeTest call
SharePtr construct...， copy other sharePtr
addRefCount, now ref count 3
will make an emptyPtr
SharePtr construct...， origin init
will set pInnerTest2
operator=
operator=， will call release
release, current _pRefCount 1
will delete  _pPtr 
addRefCount, now ref count 4
operator ->
Test printSomething
will make one test
Test class construct
Test printSomething
Test class destruct
SharePtr destruct...
release, current _pRefCount 4
SharePtr destruct...
release, current _pRefCount 3
SharePtr destruct...
release, current _pRefCount 2
main end
SharePtr destruct...
release, current _pRefCount 1
will delete  _pPtr 
Test class destruct

总结

要实现智能指针，其关键变量有三个：
a) 指向托管对象的指针
b) 引用计数变量的指针，即一个int指针
c) 锁，用来计数或者释放对象等关键操作时加锁

关键函数，有
a) 重载这两个运算符= ->
b) 构造函数写两个，一个是参数为托管对象的指针，一个是参数为智能指针本身
c) 引用计数加
d) 引用计数减，以及减到0时释放托管对象