C++重写shared_ptr智能指针类

基于C++11中shared_ptr源码改写。全部代码都已经过测试检验。

头文件：kSharedPtr.h

#ifndef _KSHAREDPTR_H_
#define _KSHAREDPTR_H_
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
using std::auto_ptr;

template <typename T>
class KSharedPtr
{
private:
	T* m_ptr;
	int* m_count;
public:
	explicit KSharedPtr(T* p = 0);  //默认构造函数
	KSharedPtr(KSharedPtr const& r);  //复制构造函数
	KSharedPtr& operator=(KSharedPtr const& r);  //重载赋值运算符
	explicit KSharedPtr(auto_ptr<T>& r);  //用auto指针构造
	KSharedPtr& operator=(auto_ptr<T>& r);  //重载赋值运算符（通过auto）
	~KSharedPtr();  //析构函数
	T& operator*() const;  //重载*指针操作
	T* operator->() const;  //重载->操作
	bool operator==(KSharedPtr const& r);  //重载运算符==
	bool operator!=(KSharedPtr const& r);  //重载运算符!=
	T* get()const;  //返回当前存储的指针
	void reset(T* p = 0);  //重置当前存储的指针
	int getCount();  //获取引用数
};

//默认构造函数
template <typename T>
KSharedPtr<T>::KSharedPtr(T* p /* = 0 */)  
{
	this->m_ptr = p;
	try
	{
		this->m_count = new int(1);
	}
	catch (...)
	{
		delete this->m_ptr;  //申请失败，释放真实指针和引用计数的内存
		this->m_ptr = nullptr;
		delete this->m_count;
		this->m_count = nullptr;
	}
}

//复制构造函数
template <typename T>
KSharedPtr<T>::KSharedPtr(KSharedPtr const& r)
{
	this->m_count = r.m_count;
	this->m_ptr = r.m_ptr;
	++(*this->m_count);
}

//重载赋值运算符
template <typename T>
KSharedPtr<T>& KSharedPtr<T>::operator =(KSharedPtr const& r)
{
	this->m_count = r.m_count;
	this->m_ptr = r.m_ptr;
	++(*this->m_count);
	return *this;
}

//用auto指针构造
template <typename T>
KSharedPtr<T>::KSharedPtr<T>(auto_ptr<T>& r)
{
	this->m_ptr = r.release();
	this->m_count = new int(1);
}

//重载赋值运算符（通过auto）
template <typename T>
KSharedPtr<T>& KSharedPtr<T>::operator=(auto_ptr<T>& r)
{
	this->m_ptr = r.release();
	this->m_count = new int(1);
	return *this;
}

//析构函数
template <typename T>
KSharedPtr<T>::~KSharedPtr()
{
	if (--(*this->m_count) == 0)
	{
		this->m_ptr = nullptr;
		delete this->m_count;
		this->m_count = nullptr;
	}
}

//重载*指针操作
template<typename T>
T& KSharedPtr<T>::operator*()const
{
	return *this->m_ptr;
}

//重载->操作
template<typename T>
T* KSharedPtr<T>::operator->()const
{
	return this->m_ptr;
}

//重载比较运算符==
template <typename T>
bool KSharedPtr<T>::operator==(KSharedPtr const& r)
{
	if (this->m_ptr == r.m_ptr)
		return true;
	else
		return false;
}

//重载比较运算符!=
template <typename T>
bool KSharedPtr<T>::operator!=(KSharedPtr const& r)
{
	if (this->m_ptr != r.m_ptr)
		return true;
	else
		return false;
}

//返回当前存储的指针
template <typename T>
T* KSharedPtr<T>::get() const
{
	return m_ptr;
}

//获取引用数
template <typename T>
int KSharedPtr<T>::getCount()
{
	return *this->m_count;
}

//重置当前存储的指针
template <typename T>
void KSharedPtr<T>::reset(T* p)
{
	if (p == 0)
	{
		if (--(*this->m_count) == 0)
		{
			this->m_ptr = nullptr;
			delete this->m_count;
			this->m_count = nullptr;
		}
	}
	else
	{
		this->m_ptr = p;
		delete this->m_count;
		this->m_count = new int(1);
	}
}

#endif // _KSHAREDPTR_H_

测试文件：demo.cpp

#include "kSharedPtr.h"

void test1()   //测试构造函数
{
	int* a = new int(78);
	int b = 46;
	KSharedPtr<int> p1(a);
	KSharedPtr<int> p2(p1);
	KSharedPtr<int> p3 = p2;
	cout << *p3 << " " << p3.getCount();
}

void test2()   //测试auto转换相关
{
	int* a = new int(8);
	int* b = new int(25);
	auto_ptr<int> c(a);
	auto_ptr<int> d(b);
	KSharedPtr<int> p1(c),p2;
	p2 = d;
	cout << *p1 << " " << p1.getCount() << endl;
	cout << *p2 << " " << p2.getCount() << endl;
}

void test3()  //测试析构函数
{
	int a = 67;
	KSharedPtr<int> p1(&a);
	KSharedPtr<int> p2(p1);
	KSharedPtr<int> p3 = p2;
	cout << *p3 << " " << p3.getCount() << endl;
	p2.~KSharedPtr();
	p3.~KSharedPtr();
	cout << *p3 << " " << p3.getCount() << endl;
}

void test4()  //测试==、!=
{
	int a = 67;
	int b = 90;
	KSharedPtr<int> p1(&a);
	KSharedPtr<int> p2(p1);
	KSharedPtr<int> p3(&b);
	if (p3 != p1)
		cout << 1 << endl;
	else
		cout << -1 << endl;
}

void test5()  //测试get、reset
{
	int a = 67;
	int b = 90;
	KSharedPtr<int> p1(&a);
	KSharedPtr<int> p2(p1);
	KSharedPtr<int> p3 = p2;
	cout << *p3.get() <<"  "<< p3.getCount() << endl;
	p3.reset();
	cout << *p3.get() << "  " << p3.getCount() << endl;
}

int main()
{
	test5();
    
    system("pause");
}