智能引用模板类调用方法

#ifndef _AUTOREFER_H
#define _AUTOREFER_H
template <class T>
class CAutoRefer
{
public:
	CAutoRefer()
	{
		m_oper = new T;
	}
	CAutoRefer(T * p)
	{
		m_oper = p;
	}
	operator T*()
	{
		return m_oper;

	}
	virtual ~CAutoRefer()
	{
		Release();
	}
	T* operator*() { return m_oper; }
	T** operator &(){ return &m_oper; }
	T* operator ->() { return m_oper; };

	T* GetInterface()
	{
		return m_oper;

	}
	int Attach(T* pinterface, bool baddref = true)
	{
		if (m_oper == pinterface)
		{
			return 0;
		}
		Release();
		m_oper - pinterface；
		if (baddref){
			m_oper->AddRef();
		}
		return 0;
	}
	int Detech()
	{
		Release();
		return 0;
	}
	void Release()
	{
		if (m_oper)
		{
			m_oper->Release();
			m_oper = NULL;
		}
	}

private:
	T* m_oper;

};


#endif

　　

#pragma once
#include <Windows.h>
class CriticalSection  {
public:
	CriticalSection() : isLocked_(false)
	{
		InitializeCriticalSection(&cs_);
	}

	~CriticalSection()
	{
		DeleteCriticalSection(&cs_);
	}

	inline void lock() {
		EnterCriticalSection(&cs_);
		isLocked_ = true;
	}

	inline void unlock() {
		LeaveCriticalSection(&cs_);
		isLocked_ = false;
	}

	inline bool isLocked() const {
		return isLocked_;
	}

	/*
	inline const CRITICAL_SECTION* getHandle() const {
	return &cs_;
	}
	*/
protected:

	CRITICAL_SECTION cs_;

	bool isLocked_;

};

class CriticalFunction
{
private:
	CriticalSection &m_cllock;
	int m_block;
public:
	CriticalFunction(CriticalSection &cllock) :m_cllock(cllock), m_block(false)
	{
		Lock();
	}

	~CriticalFunction()
	{
		Unlock();
	}

	inline void Unlock()
	{
		if (m_block)
		{
			m_cllock.unlock();
			m_block = false;
		}
	}

	inline void Lock()
	{
		if (!m_block)
		{
			m_cllock.lock();
			m_block = true;
		}
	}

};

　　

#pragma once
class CDataReference
{
public:
	CDataReference();
	virtual ~CDataReference();
	int AddRef(void);
	int Release(void);
private:
	int     m_nref;
	void*   m_refcs;
};

class msgdata
{
public:
	msgdata();
	~msgdata();
};

　　

#include "stdafx.h"
#include "msgdata.h"

#include "CriticalSection.h"
CDataReference::CDataReference()
{
	m_nref = 1;
	m_refcs = (void *)new CriticalSection();
}

CDataReference::~CDataReference()
{
	delete  (CriticalSection *)(m_refcs);
}

int CDataReference::AddRef(void)
{
	CriticalFunction lock(*((CriticalSection *)m_refcs));
	return ++m_nref;
}
int CDataReference::Release(void)
{
	int  nret = -1;
	{
		CriticalFunction lock(*((CriticalSection *)m_refcs));
		nret = --m_nref;
	}

	if (nret == 0)
	{
		delete this;
	}
	return nret;
}



msgdata::msgdata()
{
}


msgdata::~msgdata()
{
}