智能引用模板类调用方法

#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()
{
}