让静态成员函数具有多态性(浅谈如何使回调函数具有多态性)

// 在Windows编程中,经常要用到回调函数.要封装具有回调函数的对象

//就将回调函数设为类的静态成员函数,而在C++中,静态成员函数是没有多态性的.

//如何使静态函数具有"多态性的行为"呢,下面通过封装thread来说明这一技巧

 

//主要体现在static unsigned  int __stdcall ThreadProxy( void *pvParam )

//和int Create()两个函数上面

 

 

//MyThread.h

#pragma once

typedef unsigned(__stdcall *pThreadFunc)(void*);

#define smBeginThread(psa,cbStack,pfnStartAddr,pvParam, /

    dwCreate,pdwThreadId)                                       /

    (HANDLE)_beginthreadex(psa,(unsigned int)cbStack,                         /

    (pThreadFunc)pfnStartAddr,(void*)pvParam,dwCreate,(unsigned*)pdwThreadId)

class CMyThread

{

private:

    //禁止拷贝和将对象赋值给其他对象

    CMyThread(CMyThread&);

    CMyThread & operator =(CMyThread&);

private:

    static unsigned  int __stdcall ThreadProxy( void *pvParam );

protected:

    virtual int Run(void *pvParam)=0;

    ~CMyThread(void);        //使对象只能从堆中创建

protected:

    HANDLE _hThread;

public:

    enum _DESTROY_TYPE{_dtWAIT=0,   //阻塞等待线程直到线程退出

       _dtTRY,                            //如果线程已经退出,则删除,否则立刻返回

       _dtTERMINATE};                  //强制关闭线程

   

public:

    CMyThread(void);

   

    int Create(LPVOID pvParam,DWORD dwCreate=CREATE_SUSPENDED

       ,LPSECURITY_ATTRIBUTES psa=NULL,SIZE_T cbStack=0

       ,LPDWORD pdwThreadId=NULL);

    int Suspend();

    int Resume();

    int Terminate( DWORD dwExitCode); 

    //当_hThread==NULL,立刻返回-1; 不开预料的错误:返回-2

    //当成功删除,返回0,否则返回STILL_ACTIVE

    int Destroy(_DESTROY_TYPE dt,DWORD & dwExitCode,DWORD const dwWaitTimes);

    BOOL GetExitCode(DWORD &dwExitCode);

    HANDLE GetHandle();

    DWORD GetId();

   

};

 

 

 

 

 

 

//MyThread.cpp

 

#include "StdAfx.h"

#include <Windows.h>

#include <process.h>

#include "./mythread.h"

#ifndef ASSERT

#include <cassert>

#define ASSERT(s) assert(s)

#endif

namespace

{

    class _ThreadProxy

    {

       friend CMyThread;

       _ThreadProxy(_ThreadProxy&);

       _ThreadProxy& operator =(_ThreadProxy);

    private:

       CMyThread* _pThis;

       void *_pvParam;

       _ThreadProxy(CMyThread*thread,void *pvParam)

           :_pThis(thread)

           ,_pvParam(pvParam)

       {

       }

    };

}

CMyThread::CMyThread(void)

:_hThread(0)

{

}

 

CMyThread::~CMyThread(void)

{

    if (_hThread)

    {

       CloseHandle(_hThread);

    }

    _hThread=NULL;

}

unsigned int CMyThread::ThreadProxy( void *pvParam )

{

    _ThreadProxy *proxy=(_ThreadProxy*)pvParam;

    ASSERT(proxy);

    CMyThread*pThis=proxy->_pThis;

    void *param=proxy->_pvParam;

    delete proxy;

    return (unsigned int)pThis->Run(param);

}

 

int CMyThread::Create(LPVOID pvParam,DWORD dwCreate/* =CREATE_SUSPENDED  */,

                          LPSECURITY_ATTRIBUTES psa/* =NULL */

                          ,SIZE_T cbStack/* =0  */,LPDWORD pdwThreadId/* =NULL */)

{

    _hThread=smBeginThread(psa,cbStack,ThreadProxy,

       (new _ThreadProxy(this,pvParam))   ,dwCreate,pdwThreadId);

    ASSERT(_hThread);

    return _hThread?0:-1;

}

int CMyThread::Suspend()

{

    ASSERT(_hThread);

    return ::SuspendThread(_hThread);

}

int CMyThread::Resume()

{

    ASSERT(_hThread);

    return ::ResumeThread(_hThread);

}

int CMyThread::Terminate( DWORD dwExitCode)

{

    ASSERT(_hThread);

    return ::TerminateThread(_hThread,dwExitCode);

}

HANDLE CMyThread::GetHandle()

{

    return _hThread;

}

DWORD CMyThread::GetId()

{

    ASSERT(_hThread);

    return ::GetThreadId(_hThread);

}

BOOL CMyThread::GetExitCode(DWORD & dwExitCode)

{

    ASSERT(_hThread);

    return ::GetExitCodeThread(_hThread,&dwExitCode);

}

 

//当_hThread==NULL,立刻返回-1; 不开预料的错误:返回-2

//当成功删除,返回0,否则返回返回1

int CMyThread::Destroy(_DESTROY_TYPE dt,DWORD & dwExitCode,

                           DWORD const dwWaitTimes/* =0 */)

{

    int iRet;

    if (!_hThread)

    {

       delete this;

       return -1;

    }

    switch(dt) {

    case _dtTRY:

       if (GetExitCodeThread(_hThread,&dwExitCode)==0){return -2;}

        if (dwExitCode==STILL_ACTIVE)   {   return 1;}

       break;

 

    case _dtWAIT:

       ASSERT(dwWaitTimes>=0);

       iRet=WaitForSingleObject(_hThread,dwWaitTimes); 

       if (iRet==WAIT_TIMEOUT)

       {

           dwExitCode=STILL_ACTIVE;

           return 1;

       }

       if (iRet=WAIT_OBJECT_0)

       {

           GetExitCodeThread(_hThread,&dwExitCode);        

       }     

       break;

    case _dtTERMINATE:

       if (::GetExitCodeThread(_hThread,&dwExitCode)==0){return -2;}

       if (dwExitCode==STILL_ACTIVE)

       {

           ::TerminateThread(_hThread,dwExitCode);         

       }

       break;

    }

    delete this;

    return 0;

}