c++实现智能指针

原创 2015年11月20日 16:12:13

实现代码实例:

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

版权声明:本文为博主原创文章,未经博主允许不得转载。 举报

相关文章推荐

C++ 智能指针详解

由于 C++ 语言没有自动内存回收机制,程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete,流程太复杂,最终导致没有 delete,异常导致程序过早退出,没有执行 dele...

C++中智能指针的工作原理和简单实现

原文地址:http://www.cnblogs.com/yangshaoning/archive/2012/03/18/cpp_smart_pointer.html 智能指针:它的一种通用实...

我是如何成为一名python大咖的?

人生苦短,都说必须python,那么我分享下我是如何从小白成为Python资深开发者的吧。2014年我大学刚毕业..

C++面试题(四)——智能指针的原理和实现

普通C++面试时候的一般都是这个套路:      1,C++和C相比最大的特点——面向对象:封装,继承,多态。      2,你知道虚函数吗?——实现多态所必须,父类类型的指针指向子类的实例,执行的时...

C++中智能指针的设计和使用

智能指针(smart pointer)是存储指向动态分配(堆)对象指针的类,用于生存期控制,能够确保自动正确的销毁动态分配的对象,防止内存泄露。它的一种通用实现技术是使用引用计数(reference ...

C++智能指针简单实现

#include #include #include #include namespace smart_pointer { // RAII(Resource Acquisition Is ...

c++智能指针的原理与简单实现

一、问题的引入 先看一段简单的代码如下: #include using namespace std; class Person { private: char *name ; public: ...

c++ 复制控制和智能指针实现

总结了c++中三种复制控制的场合和具体实现方法,在此基础上设计自己的智能指针类。
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)