c++ shared_ptr指针实现

#include <stdio.h>
#include <stdlib.h>
#include <string>


template<typename T>
class shared_ptr;


template<typename TT>
shared_ptr<TT>& make_shared(TT s)
{
shared_ptr<TT>* ss = new shared_ptr<TT>(new TT(s));
--*(ss->m_count);
printf("%d\n",*(ss->m_count));
return *ss;
}


template<typename T>
class shared_ptr
{
private:
T* m_ptr;
int* m_count;
public:
shared_ptr();
explicit shared_ptr(T* s);          //用explicit 修饰的构造函数，不具有隐式转换功能，只能构造对象显示调用，（不能将T* 隐式转换成临时无名的shared_ptr对象）
shared_ptr(const shared_ptr<T>&);
~shared_ptr();


T* get();
int use_count();


T* operator->();//特别的运算符，它是指向自己成员的，所以不需要参数，且由于不能与原运算符功能冲突，规定它只能重载作为函数成员
T operator*();
shared_ptr<T>& operator=(const shared_ptr<T>&s);
bool operator==(const shared_ptr<T>&s);


//friend shared_ptr<T>make_shared<T>(T s);//绑定的有元函数模板，声明时，需要在函数名后加上<> ,但是实现不需要了，且函数模板必须先存在
//可以写成
template<typename TT>
friend shared_ptr<TT>& make_shared(TT s);  //非绑定的有元函数模板，可以在之后实现函数模板
};


template<typename T>
T shared_ptr<T>::operator*()
{
if(m_ptr!=NULL)
return *m_ptr;
}


template<typename T>
T* shared_ptr<T>::operator->()
{
if(m_ptr!= NULL)
return m_prt;
else
return NULL;
}


template<typename T>
shared_ptr<T>& shared_ptr<T>::operator=(const shared_ptr<T>&s)
{
if(s.m_ptr==NULL)
{
m_ptr = NULL;
(*m_count)--;
if(*m_count == 1)
{
delete m_count;
delete m_ptr;
}
m_count = s.m_count;
}
else
{
m_ptr = s.m_ptr;
m_count = s.m_count;
(*m_count)++;
}
return *this;
}


template<typename T>
shared_ptr<T>::shared_ptr()
{
m_ptr=NULL;
m_count = new int(0);
}


template<typename T>
shared_ptr<T>::shared_ptr(T*s)
{
if(s==NULL)
{
m_ptr=NULL;
m_count = new int(0);
}
else
{
m_ptr = s;
m_count = new int(1);
}
}


template<typename T>
shared_ptr<T>::shared_ptr(const shared_ptr<T>& s)
{
if(s.m_ptr == NULL)
{
m_ptr = NULL;
m_count = s.m_count;
}
else
{
m_ptr = s.m_ptr;
m_count = s.m_count;
(*m_count)++;
}
}


template<typename T>
shared_ptr<T>::~shared_ptr()
{
if(*m_count == 1)
{delete m_ptr;
delete m_count;
}
else if(*m_count == 0)
{

}
else
{
(*m_count)--;
}
}


template<typename T>
T* shared_ptr<T>::get()
{
return m_ptr;
}


template<typename T>
int shared_ptr<T>::use_count()
{
return *m_count;
}