鍙鍦ㄥ嚱鏁板０鏄庡墠鍔爏tatic灝卞ソ浜嗭紝鍝堝搱鍝堝搱鍝垀~~~~
銆傘傘傚紑涓帺絎戙備互鍓嶇‘瀹炲ぇ瀹墮兘鏄繖鏍峰仛鐨勶紝鍦ㄩ潤鎬佺殑鎴愬憳鍑芥暟涓啀鏌ユ壘this鎸囬拡錛屽畠澶氬崐鏄叏灞鍙橀噺錛屾垨鑰呮槸鍥炶皟鍑芥暟鎻愪緵鐨勯檮鍔犲弬鏁般傚鏋滄槸鍓嶈咃紝灝變細澶уぇ鐮村潖紼嬪簭鐨勭粨鏋勩傝岀幇鍦紝闅忕潃紺句細鐢熶駭鍔涚殑鍙戝睍錛屽伓浠凡緇忚兘鍋氬埌灝嗘垚鍛樺嚱鏁版槧灝勬垚涓轟竴涓復鏃剁殑闈欐佸嚱鏁頒簡銆傛湰鏂囧氨鏉ユ紨紺轟竴涓嬭繖縐嶅疄鐜版柟寮忋?/p>
棣栧厛闇瑕佸寘鍚竴涓敱yzwykkldczsh鍚屽織緙栧啓鐨勬ā鏉跨被-----涓囪兘澶氱敤鑷傚簲鏃犻檺鍒跺洖璋冩ā鏉匡紙涓虹邯蹇靛弸浜篺ishskin錛屾妯℃澘鍙堢О涓篐>W妯℃澘錛?nbsp;
/**************************************************************************
* ACCallback.h
* Helper class of Member function callback mechanism
**************************************************************************/
#include "stdafx.h"
#include "windows.h"
#pragma pack(push, 1)
struct _ACCallbackOpCodes
{
unsigned char tag; // CALL e8
LONG_PTR offset; // offset (dest - src - 5, 5=sizeof(tag + offset))
LONG_PTR _this; // a this pointer
LONG_PTR _func; // pointer to real member function address
};
#pragma pack(pop)
static __declspec( naked ) int STDACJMPProc()
{
_asm
{
POP ECX
MOV EAX, DWORD PTR [ECX + 4] // func
MOV ECX, [ECX] // this
JMP EAX
}
}
static LONG_PTR CalcJmpOffset(LONG_PTR Src, LONG_PTR Dest)
{
return Dest - (Src + 5);
}
/*
* NOTE: _TPStdFunc: a type of function pointer to API or Callbacks, *MUST* be _stdcall
_TPMemberFunc: a type of function pointer to class member function,
*MUST* be the *DEFAULT* calling conversation, *NO* prefix should be added,
that is, using ECX for "this" pointer, pushing parameters from right to left,
and the callee cleans the stack.
_TClass: the class who owns the callback function. The caller should only own the _stdcall function pointer
LIFE TIME: It is important to keep the ACCallback object alive until the CALLBACK is not required!!!
*/
template<typename _TPStdFunc, class _TClass, typename _TPMemberFunc>
class ACCallback
{
public:
_TClass *m_pThis;
_TPMemberFunc m_pFunc;
private:
_TPStdFunc m_pStdFunc;
void MakeCode()
{
if (m_pStdFunc) ::VirtualFree(m_pStdFunc, 0, MEM_RELEASE);
m_pStdFunc = (_TPStdFunc)::VirtualAlloc(NULL, sizeof(_ACCallbackOpCodes), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
_ACCallbackOpCodes *p = (_ACCallbackOpCodes *)m_pStdFunc;
p->_func = *(LONG_PTR *)&m_pFunc;
p->_this = (LONG_PTR)m_pThis;
p->tag = 0xE8;
p->offset = CalcJmpOffset((LONG_PTR)p, (LONG_PTR)STDACJMPProc);
}
public:
ACCallback<_TPStdFunc, _TClass, _TPMemberFunc>()
{
}
ACCallback<_TPStdFunc, _TClass, _TPMemberFunc>(_TClass* pThis,
_TPMemberFunc pFunc
)
{
m_pFunc = pFunc;
m_pThis = pThis;
m_pStdFunc = NULL;
MakeCode();
}
void Assign(_TClass* pThis,
_TPMemberFunc pFunc
)
{
m_pFunc = pFunc;
m_pThis = pThis;
m_pStdFunc = NULL;
MakeCode();
}
~ACCallback<_TPStdFunc, _TClass, _TPMemberFunc>()
{
::VirtualFree(m_pStdFunc, 0, MEM_RELEASE);
}
operator _TPStdFunc()
{
return m_pStdFunc;
}
};
/********************************** EXAMPLE **********************************
class CClass1
{
public:
TCHAR m_Buf[255];
BOOL EnumWindowProc(HWND hwnd, LPARAM lp)
{
GetWindowText(hwnd, m_Buf, 255);
printf("Enum window=%s\n", m_Buf);
return TRUE;
}
typedef BOOL (CClass1::*CLASSWNDENUMPROC)(HWND, LPARAM);
};
TO USE:
CClass1 c1;
ACCallback<WNDENUMPROC, CClass1, CClass1::CLASSWNDENUMPROC> cb(&c1, &CClass1::EnumWindowProc);
EnumWindows(cb, 0);
************************* END OF EXAMPLE *********************************/
妯℃澘鐨勪笁涓弬鏁板垎鍒槸錛欰PI鍑芥暟鎸囬拡鐨勭被鍨嬶紝綾誨悕瀛楋紝綾繪垚鍛樺嚱鏁版寚閽堢殑綾誨瀷錛堜袱縐嶅嚱鏁版寚閽堝湪鍙傛暟鍜岃繑鍥炲間笂搴旇涓鏍鳳紝鍙槸鍓嶈呭０鏄庝負_stdcall錛屽悗鑰呬笉鍔犱換浣曡皟鐢ㄤ慨楗幫紝鍗抽粯璁ょ殑__thiscall鏂瑰紡錛?br>璇ラ」澶存枃浠剁殑娉ㄩ噴涓粰浜嗕竴涓皟鐢ˋPI鍑芥暟EnumWindows鐨勪緥瀛愩傜幇鍦ㄥ伓浠潵璇曡瘯璋冪敤SetTimer銆?/p>
class CTestCallback
{
private:
/* A callback of SetTimer, mirrored into member OnTimer */
typedef void (CTestCallback::*CLASSTIMERPROC)(HWND, UINT, UINT_PTR, DWORD);
void OnTimer (HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime);
ACCallback<TIMERPROC, CTestCallback, CLASSTIMERPROC> m_DOnTimer;
}
璋冪敤鏃訛紝鍙榪欐牱鍐欙細
/* 鍒濆鍖栧洖璋冪粨鏋?*/
m_DOnTimer.Assign(this, &CTestCallback::OnTimer);
m_uid = ::SetTimer( NULL, 0, 1000, m_DOnTimer);
鏈鍚庤寰楀湪CTestCallback鐨勬瀽鏋勫嚱鏁頒腑KillTimer銆傜敱浜巑_DOnTimer浼氬疄鐜拌漿鍖栧埌闈欐佸嚱鏁版寚閽堢被鍨嬬殑鎿嶄綔絎︼紝鎵浠ヨ皟鐢ㄧ殑鍦版柟鍙鐩存帴鍐欏洖璋冪粨鏋勭殑鍚嶅瓧灝卞彲浠ヤ簡銆?/p>
浣跨敤璇ユā鏉塊渶瑕佹敞鎰忎袱鐐癸細
1.API鍑芥暟搴斿綋鏄痏stdcall綾誨瀷鐨勶紙榪欎竴鐐圭粷澶ч儴鍒咥PI閮芥弧瓚籌級銆傜被鎴愬憳鍑芥暟蹇呴』鏄粯璁ょ殑璋冪敤鏂瑰紡錛屼笉瑕佸姞_stdcall鎴朹cdecl涔嬬被鐨勪慨楗般傛鏂瑰紡鐨勯噸瑕佹潯浠跺氨鍦ㄤ簬_stdcall鍜宊_thiscall涔嬮棿鍙浉宸簡涓涓狤CX鎸囧嚭鐨則his鎸囬拡錛屾墍浠ユ垜浠墠鑳藉疄鐜拌繖縐嶆槧灝勶紙榪欑鏂瑰紡鍦╒CL鍜孉TL鐨勭獥鍙ｇ被涓兘鏈変嬌鐢ㄥ埌錛夛紱
2.鍥炶皟緇撴瀯鐨勭敓瀛樺懆鏈熷簲褰撴槸鍦ㄦ暣涓洖璋冨嚱鏁版湁鏁堢殑鏃墮棿鍐呫傚洜姝わ紝瀵逛簬EnumWindows榪欐牱鐨勫嚱鏁幫紝鍙澹版槑鍦ㄦ爤涓婂氨鍙互浜嗭紱浣嗗浜嶴etTimer錛屽氨蹇呴』瀹氫箟涓虹被鎴愬憳鍙橀噺錛屽悓鏃訛紝鍦ㄧ被鐨勬瀽鏋勫嚱鏁頒腑蹇呴』鍙婃椂閿姣佽繖涓猼imer銆?/p>
]]>
After reviewing the comments and suggestions from a few people, I made the solution better. Look for an update to this article which uses a better approach, namely using the functions:
CreateWaitableTimer()SetWaitableTimer()WaitForMultipleObjects()
The solution based on these functions will allow multiple instances of the CSleeperThread class to run (instead of just one using the current example). So stay tuned, I'll have this article updated as soon as possible. :-)
Introduction
I have seen many questions on the boards about how to properly use SetTimer(). I've also noticed that most of these questions are around how to put a thread to sleep for X seconds. One obvious answer would be to use the Sleep() function. The main drawback is, how do you gracefully shut down your thread, or cancel the Sleep() operation before the time expires.
This article is meant to address all of the above. I give an example of putting a thread to sleep using SetTimer(). The SetTimer() calls back to a non-static function. This is key, because normally you have to pass a static member to SetTimer() which means it can't access any other non-static variables or member functions of the class.
Details
Since implementing a non-static callback member is key to this, we'll go into this first. Implementing a callback to a static member function doesn't require anything different from implementing a regular C callback function. Since static member functions have the same signature as C functions with the same calling conventions, they can be referenced using just the function name.
Making a non-static callback member function is a different story, because they have a different signature than a C function. To make a non-static member function, it requires the use of two additional items:
- A global (
void*) pointer, referencing the class of the callback function - A wrapper function which will be passed to
SetTimer()
This is actually a fairly simple implementation. First, you need to define your class:
class CSleeperThread : public CWinThread { public: static VOID CALLBACK TimerProc_Wrapper( HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime ); VOID CALLBACK TimerProc( HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime ); void ThreadMain(); void WakeUp(); private: static void * pObject; UINT_PTR pTimer; CRITICAL_SECTION lock; };
Then, don't forget to include the following line in your class implementation file:
void * CSleeperThread::pObject;
Now that we have our class declared, we can look at the wrapper function, the non-static member function and the member function that will call SetTimer():
VOID CALLBACK CSleeperThread::TimerProc_Wrapper( HWND hwnd, UINT uMsg,
UINT idEvent, DWORD dwTime ) {
CSleeperThread *pSomeClass = (CSleeperThread*)pObject; // cast the void pointer
pSomeClass->TimerProc(hwnd, uMsg, idEvent, dwTime); // call non-static function
}
The wrapper function first initializes a CSleeperThread pointer with pObject. Since pSomeClass is a local pointer, we can access it within the static wrapper function.
VOID CALLBACK CSleeperThread::TimerProc(HWND hwnd,
UINT uMsg, UINT idEvent, DWORD dwTime) {
::EnterCriticalSection(&lock);
if(idEvent == pTimer) {
KillTimer(NULL, pTimer); // kill the timer so it won't fire again
ResumeThread(); // resume the main thread function
}
::LeaveCriticalSection(&lock);
}
The TimerProc member function isn't static, so we can access other non-static functions like ResumeThread() and we can access the private variable lock. Notice that I've entered a critical section which prevents a second timer event to enter the callback, thus ensuring that the first execution of TimerProc() will cancel out the timer.
Next, let's take a look at the main execution function, ThreadMain().
void CSleeperThread::ThreadMain() { pObject = this; // VERY IMPORTANT, must be initialized before // calling SetTimer() // call SetTimer, passing the wrapper function as the callback pTimer = SetTimer(NULL, NULL, 10000, TimerProc_Wrapper); // suspend until the timer expires SuspendThread(); // the timer has expired, continue processing }
The first step in ThreadMain() is absolutely critical. We need to assign the class instance pointer (this) to the pObject variable. This is how the wrapper callback function will gain access to execute the non-static member function.
Next, we just call SetTimer() passing in a function pointer to our wrapper function. SetTimer() will call the wrapper function when the timer expires. The wrapper function in turn, will execute the non-static function TimerProc(), by accessing the static variable pSomeClass.
NOTE: I chose to implement a main function that will create the timer, go to sleep, continue processing and then exit when finished. This is in effect a function that will only execute once per timer. You could easily add a loop to ThreadMain() which would execute once for each timer event.
One last little function. Since we used SuspendThread() in ThreadMain(), if we need to wake up the thread (for whatever reason), all we have to do is make a call to ResumeThread(). So, I've added an access function like so:
void WakeUp() { ::EnterCriticalSection(&lock); KillTimer(NULL, pTimer); ResumeThread(); // wake the thread up }
Buh dee buh dee, that's all folks...
And there we have it. A thread safe class that goes to sleep using SetTimer() and a non-static callback function; which also has the ability to wake up before the timer expires.
Hopefully, you have found this helpful. I've actually used this code in a project I'm working on now, and was in hopes someone else would get some good use out of it.
Someone once told me "you'll like programming if you like banging your head against the wall repeatedly". I've found that to be true, it took me literally several days to figure out what I've put into this article, I'm just slow I guess.
Whew, my head hurts, time for some Advil...or Ibooprofin.. or asssprin.... or something.
Credits...
I probably learned way more in the process of writing this article. So, much thanks goes to Lars Haendel for creating a web-site dedicated to understanding function pointers, without which I wouldn't know didley.
]]>