#ifndef SHARED_PTR_H_
#define SHARED_PTR_H_
#ifndef NULL
#define NULL 0
#endif
namespace util
{
template <class T>
class shared_ptr;
template <class T>
class shared_data
{
private:
friend class shared_ptr<T>;
explicit shared_data(T *pT): _M_ptr(pT)
{
_M_nCount = 1;
}
~shared_data()
{
delete _M_ptr;
}
void operator++()
{
++_M_nCount;
}
void operator--()
{
--_M_nCount;
if (_M_nCount == 0)
{
delete this;
}
}
T &operator *()const
{
return *_M_ptr;
}
T *operator->()const
{
return _M_ptr;
}
bool operator == (T *pT)const
{
return _M_ptr == pT;
}
T *get()
{
return _M_ptr;
}
int use_count()
{
return _M_nCount;
}
private:
T *_M_ptr;
unsigned int _M_nCount;
};
template <class T>
class shared_ptr
{
typedef shared_data<T> element;
public:
explicit shared_ptr(T *pT): _M_pD(NULL)
{
_M_pD = new element(pT);
}
explicit shared_ptr(): _M_pD(NULL)
{
}
// copy constructor
shared_ptr(const shared_ptr < T > &rT)
{
_M_pD = rT.get_element();
if (_M_pD != NULL)
{
++(*_M_pD);
}
}
~shared_ptr()
{
if (_M_pD != NULL)
{
--(*_M_pD);
}
}
// assignment operator
shared_ptr < T > &operator = (const shared_ptr < T > &rT)
{
if (_M_pD != NULL)
{
--(*_M_pD);
}
_M_pD = rT.get_element();
if (_M_pD != NULL)
{
++(*_M_pD);
}
return *this;
}
// assignment operator
shared_ptr < T > &operator = (shared_ptr < T > &rT)
{
if (_M_pD != NULL)
{
--(*_M_pD);
}
_M_pD = rT.get_element();
if (_M_pD != NULL)
{
++(*_M_pD);
}
return *this;
}
T &operator *()const
{
return _M_pD->operator *();
}
T *operator->()const
{
return _M_pD->operator->();
}
bool operator == (shared_ptr < T > &rT)const
{
return rT.get_element() == _M_pD;
}
bool operator == (T *pT)const
{
if (_M_pD == NULL)
{
return pT == NULL;
}
return *_M_pD == pT;
}
T *get()
{
if (_M_pD == NULL)
{
return NULL;
}
else
{
return _M_pD->get();
}
}
void release()
{
if (_M_pD != NULL)
{
--(*_M_pD);
_M_pD = NULL;
}
}
void reset(T *pT)
{
if (_M_pD != NULL)
{
--(*_M_pD);
_M_pD = NULL;
}
_M_pD = new element(pT);
}
private:
element *get_element()const
{
return _M_pD;
}
element *_M_pD;
};
}
#endif
