实现代码实例:
SmartPtr.h
#include "Mutex.h"
#include <iostream>
class CRef //as smarty pointer counter,
{
public:
CRef():_ref(0){}
virtual ~CRef(){}
CRef(const CRef&):_ref(0)
{}
CRef& operator=(const CRef&)
{
return *this;
}
virtual void IncRef()
{
mutex.Lock();
++_ref;
mutex.UnLock();
}
virtual void DecRef()
{
mutex.Lock();
--_ref;
mutex.UnLock();
if(_ref == 0)
{
delete this;
}
}
virtual int getRef()
{
mutex.Lock();
return _ref;
mutex.UnLock();
}
private:
int _ref;
Mutex mutex;
};
template <typename T>
class SmartPtr
{
public:
SmartPtr(T* ptr):m_ptr(ptr)
{
if(m_ptr)
{
m_ptr->IncRef();
}
std::cout << "SmatePtr:: SmatePtr()invoke\n";
}
SmartPtr():m_ptr(new T())
{
if(m_ptr)
{
m_ptr->IncRef();
}
std::cout << "SmatePtr:: SmatePtr()invoke\n";
}
virtual ~SmartPtr()
{
if(m_ptr)
{
m_ptr->DecRef();
}
std::cout << "SmatePtr:: ~SmatePtr()invoke\n";
}
SmartPtr(const SmartPtr& sptr)
{
this->m_ptr = sptr.m_ptr;
if(this->m_ptr)
{
this->m_ptr->IncRef();
}
std::cout << "SmatePtr:: SmatePtr()invoke\n";
}
SmartPtr& operator=(const T& p)
{
if(this->m_ptr != p)
{
if(p)
{
p->IncRef();
}
T* ptr = this->m_ptr;
this->m_ptr = p;
if(ptr)
{
ptr->DecRef();
}
}
return *this;
}
SmartPtr& operator=(const SmartPtr& sptr)
{
if(this->m_ptr != sptr.m_ptr)
{
if(sptr.m_ptr)
{
sptr.m_ptr->IncRef();
}
T* ptr = this->m_ptr;
this->m_ptr = sptr.m_ptr;
if(ptr)
{
ptr->DecRef();
}
}
return *this;
}
T* get()const { return m_ptr;}
T* operator->()const
{
if(m_ptr)
{
return m_ptr;
}
}
T& operator*() const
{
if(m_ptr)
{
return *(m_ptr);
}
}
operator bool() const
{ return m_ptr?true:false;}
private:
T* m_ptr;
};
template <typename T, class U>
inline bool operator==(const SmartPtr<T>& lhs, const SmartPtr<U>& rhs)
{
T* l = lhs.get();
U* r = rhs.get();
if(l && r)
{
return *l == *r;
}
return !l && !r;
}
template <typename T, class U>
inline bool operator!=(const SmartPtr<T>& lhs, const SmartPtr<U>& rhs)
{
return !operator==(lhs, rhs);
}
测试代码:
TestSmart.cpp
#include "SmartPtr.h"
#include <iostream>
class Test :public CRef
{
public:
Test():data(0)
{
std::cout << "test::test invoke\n";
}
Test(int a):data(a)
{
std::cout << "test::test invoke\n";
}
virtual ~Test()
{
std::cout << "test::~test() invoked\n";
}
private:
int data;
};
int main(int argc, char *argv[])
{
// Test *t = new Test(10);
// SmartPtr<Test> p(t);
// SmartPtr<Test> p2(p);
// SmartPtr<Test> p3 = p2;
SmartPtr<Test> t;
return 0;
}
Mutex.h
#include <cstdlib>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <cstdio>
#include <string.h>
class Mutex
{
public:
Mutex();
virtual ~Mutex();
void Lock();
void UnLock();
private:
friend class CondVar;
pthread_mutex_t m_mutex;
Mutex(const Mutex&);
void operator=(const Mutex&);
};
class CondVar
{
public:
explicit CondVar(Mutex* mu);
virtual ~CondVar();
void Wait();
void Signal();
void SignalAll();
private:
pthread_cond_t m_cond;
Mutex *m_mu;
};
class CASLock
{
public:
CASLock(void* lock);
virtual ~CASLock();
void Lock();
void UnLock();
bool TryLock();
private:
void* m_lock;
};
static void MutexErr(const char* err, int res)
{
if(res != 0)
{
fprintf(stderr, "pthread %s: %s\n", err, strerror(res));
return;
}
}
Mutex::Mutex()
{
MutexErr("init mutex", pthread_mutex_init(&m_mutex, NULL));
}
Mutex::~Mutex()
{
MutexErr("destroy mutex", pthread_mutex_destroy(&m_mutex));
}
void Mutex::Lock()
{
MutexErr("lock mutex", pthread_mutex_lock(&m_mutex));
}
void Mutex::UnLock()
{
MutexErr("unlock mutex", pthread_mutex_unlock(&m_mutex));
}
CondVar::CondVar(Mutex* mu):m_mu(mu)
{
MutexErr("init cond", pthread_cond_init(&m_cond, NULL));
}
CondVar::~CondVar()
{
MutexErr("destroy cond", pthread_cond_destroy(&m_cond));
}
void CondVar::Wait()
{
MutexErr("wait cond", pthread_cond_wait(&m_cond, &m_mu->m_mutex));
}
void CondVar::Signal()
{
MutexErr("signal cond", pthread_cond_signal(&m_cond));
}
void CondVar::SignalAll()
{
MutexErr("broadcast cond", pthread_cond_broadcast(&m_cond));
}
CASLock::CASLock(void* lock):m_lock(lock){}
CASLock::~CASLock(){}
void CASLock::Lock()
{
while(!__sync_bool_compare_and_swap((int*)m_lock, 0, 1))
{
sched_yield();
}
}
void CASLock::UnLock()
{
*((int*)m_lock) = 0;
}
bool CASLock::TryLock()
{
if(__sync_bool_compare_and_swap((int*)m_lock, 0, 1))
return 0;
else
return -1;
}
编译:
g++ -o test SmartPtr.h TestSmart.cpp Mutex.h