智能指针实现代码--定时器实例

最新推荐文章于 2022-12-13 10:14:49 发布

原创最新推荐文章于 2022-12-13 10:14:49 发布 · 1.3k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#C++ #智能指针

C++ 专栏收录该内容

27 篇文章

订阅专栏

本文详细介绍了如何使用智能指针实现一个高效、可靠的定时器类，包括注册、注销定时器以及定时器的运行机制。通过模板类的设计，使得定时器能够灵活应用于不同场景，提高代码复用性和可维护性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

话不多说，直接看实现源码。

// 单线程模型，自增减没有互斥处理
class SingleThread
{
public:
	static long _Increment(long* p){ return ++(*p); }
	static long _Decrement(long* p){ return --(*p); }

};
// 计数器类
template<class ThreadModel = SingleThread>
class Counter
{
public:
	Counter() : _m_val(0){}
	long _Increment(){ return ThreadModel::_Increment(&_m_val); }
	long _Decrement(){ return ThreadModel::_Decrement(&_m_val); }
	long _GetCount(){ return _m_val; }
private:
	long _m_val;
};

template<class T>
class _MemPtr : public T
{
public:
	_MemPtr(){}
private:
	long _Increment();
	long _Decrement();
};
// 普通对象智能指针模板类，参数T必须从Counter继承
template<class T>
class MemPtr
{
public:
	MemPtr() : m_p(NULL){}
	MemPtr(T* p) : m_p(p){ AddRef(); }	// ，
	MemPtr(const MemPtr<T>& s) : m_p(s.m_p){ AddRef(); }
	~MemPtr(){ Release(); }
	MemPtr<T>& operator=(const MemPtr<T>& r)
	{
		if(m_p != r.m_p){ Release(); m_p = r.m_p; AddRef(); }
		return *this;
	}
	operator T*() { return m_p; }
	_MemPtr<T>* operator->() const { return (_MemPtr<T>*)m_p; }
	bool operator==(const MemPtr<T>& r) const{ return m_p == r.m_p; }
	bool operator!=(const MemPtr<T>& r) const{ return m_p != r.m_p; }
	bool operator!() const{ return !m_p; }
	operator bool() const{ return m_p != NULL; }
	void Attach(T* p){ Release(); m_p = p; }
	T* Detach(){ T* p = m_p; m_p = NULL; return p; }
	void Release()
	{
		if(m_p)
		{
			if(m_p->_Decrement() == 0){ delete m_p; }
			m_p = NULL;
		}
	}
	T* Copy() { AddRef(); return m_p; }
	long GetRef() const		// Used for debugging
	{
		if(m_p) return m_p->_GetCount(); return -1;
	}
	T* m_p;					// 请勿直接改写此变量
protected:
	void AddRef(){ if(m_p) m_p->_Increment(); }
};

以下是基于智能指针的定时器简单实现：

typedef unsigned long ULONG;
typedef unsigned __int64 UINT64;


class CTimer
{
public:
	CTimer(){}
	~CTimer(){}
public:
	void RegisterTimer( UINT64 id, ULONG period, UINT64 times );
	void UnRegisterTimer( UINT64 id );
	void RunTimer();
private:
	struct _TimerInfo : public Counter<>
	{
		ULONG ulLastTime;
		ULONG ulNextTime;
		ULONG ulPeriod;
		UINT64 uiTimes;
		_TimerInfo():uiTimes(0),ulLastTime(0),ulNextTime(0),ulPeriod(0){}
	};
	typedef map< UINT64, SmartPointer<_TimerInfo> >_TimerMap;
	_TimerMap m_timer;

	static UINT64 m_id;

};

UINT64 CTimer::m_id = 0;

void CTimer::RegisterTimer( UINT64 id, ULONG period, UINT64 times )
{
	SmartPointer<_TimerInfo> timer(new _TimerInfo);
	timer->ulLastTime = ::GetTickCount();
	timer->ulNextTime = timer.m_p->ulLastTime + period;
	timer->ulPeriod = period;
	timer->uiTimes = times;
	//m_id += 1;
	m_timer.insert(make_pair(id, timer));
}

void CTimer::UnRegisterTimer(UINT64 id)
{
	_TimerMap::iterator iter = m_timer.find(id);
	if( iter != m_timer.end())
	{
		m_timer.erase(id);
	}
}

void CTimer::RunTimer()
{
	while( 1 )
	{
		_TimerMap::iterator iter = m_timer.begin();
		for( ;iter != m_timer.end(); ++iter)
		{
			ULONG now = ::GetTickCount();
			if( now >= iter->second->ulNextTime  )
			{
				if( m_id == 3 ) break;
				printf("timer id is:%d\n",iter->first);
				iter->second->ulLastTime = now;
				iter->second->ulNextTime = now + iter->second->ulPeriod;
				m_id += 1;
			}
		}
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	CTimer timer;
	//timer.RegisterTimer(1, 1000, 5);
	timer.RegisterTimer(2, 2000, 3);
	timer.RunTimer();
	
	return 0;
}