线程的封装技巧：把任意类的成员函数指针作为参数

线程的封装很简单，并没有多少东西，但是如果我告诉你，我封装的这个线程类里有个成员函数Start，作用是开启线程运行，可以这样调用：

class a
{
public:
 DWORD ThreadFunca(LONG lParam);
 void StartThread();
 CMyThread m_thread;
}

DWORD a::ThreadFunca(LONG lParam)
{
 //线程执行代码 ...
}

class b
{
public:
 DWORD ThreadFuncb(LONG lParam);
 void StartThread();
 CMyThread m_thread;
}

DWORD b::ThreadFuncb(LONG lParam)
{
 //线程执行代码 ...
}

//调用代码：
void a::StartThread()
{
   m_thread.Start(this,(THREADFUNC)ThreadFunca);
}

void b::StartThread()
{
   m_thread.Start(this,(THREADFUNC)ThreadFuncb);
}

    你是不是会觉得很神奇呢？a和b是完全不相干的两个类，但其成员函数却能作为参数传进去。这个Start并不是宏，那其参数是怎么定义的呢？

    聪明的你一定已经想到模板了，不错，这个Start是一个模板函数，但是调用时却见不到模板调用时常见的xxx<yyy>格式，并且调用的类，这个线程类产生对象时也不需要把具体数据类型传入，这里用到了一点技巧。

    首先，想象一下这个Start的实现机制，按线程实现的规则，一定是先把线程函数定位到一个全局或静态的线程处理函数，然后由这个函数转到具体的成员处理函数。这样，这个函数就必须知道类a或b的成员函数指针，加上原来线程需要传入的参数，因此传入这个全局线程处理函数的参数就必须是一个结构了。定义一下这个结构：
template <typename T>
struct ThreadInfo
{
 typedef DWORD (T::*THREADFUNC1)(LONG);
 T* m_obj;
 LONG m_param;
 THREADFUNC1 m_lpthreadFunc;
};

这个结构应该是作为CMyThread的成员数据，由CMyThread创建线程的时候作为参数传给线程处理函数，对用户是透明的。这时候问题来了，创建CMyThread对象的时候必须初始化这个结构，但这时候还没调用Start，并不知道具体调用类的类型，而这个结构是必须关联到具体数据类型的，CMyThread初始化的时候这个结构该是什么类型呢？这里就要用到一个数据类型强制转换的技巧了，我们先声明一个空的类，拿这个类初始化这个结构：

class NULLCLASS
{
};

为了方便，typedef一下：typedef ThreadInfo<NULLCLASS> ThInfo;
这个结构的类型就是：

class CMyThread
{
   ...
private:
   ThInfo* m_info;
};

这里额外提一下，在Borland C++ 5.02下，这个NULLCLASS只需要声明，不需要实现，即可以不加{}：class NULLCLASS;就行了，但是VC6就不行，加不加{}，其sizeof(NULLCLASS)返回的尺寸是不一样的，加了{}返回的尺寸才是对的，不知是哪个公司错了。

发现没有，这个m_info结构里有了一个DWORD NULLCLASS::THREADFUNC1)(LONG);函数指针，而这个NULLCLASS根本没有这个函数，没关系，这个NULLCLASS只是用来做数据类型转换用，顺带也转换了成员函数指针类型。为了方便，再typedef一下这个成员函数指针：typedef ThreadInfo<NULLCLASS>::THREADFUNC1 THREADFUNC;
这样这个Start就能实现了：

class CMyThread
{
public:
 CMyThread();
 ~CMyThread();

 template<typename tname>
 BOOL Start(tname* obj,THREADFUNC func,LONG param = 0)
 { 
  if(m_handle || obj == NULL || func == NULL)
   return FALSE; //已有线程运行

  ThreadInfo<tname>* lpv = new ThreadInfo<tname>;
  lpv->m_obj = obj;
  lpv->m_param = param;
  lpv->m_lpthreadFunc = (ThreadInfo<tname>::THREADFUNC1)func;
 
  m_info = (ThInfo*)lpv;
   DWORD gdwThreadId = 0;
  m_handle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)ThreadProc,m_info,0,&gdwThreadId);
  return (BOOL)m_handle;
 }
 ...

private:
 static DWORD WINAPI ThreadProc(ThInfo* obj);

private:
 HANDLE m_handle;
 ThInfo* m_info;
};

ThreadProc就很简单了：

DWORD WINAPI CMyThread::ThreadProc(ThInfo* obj)
{
 if(obj)
  return (obj->m_obj->*(obj->m_lpthreadFunc))(obj->m_param);
 return 0;
}

这样就可以象上面的代码那样调用：m_thread.Start(this,(THREADFUNC)ThreadFunca);了，利用typename，把this指针传递进去，会自动判别数据类型，再利用NULLCLASS作为数据类型转换过个桥，这样就实现任意类的成员函数指针传递了。而传统的解决方法就需要在调用时多实现一个全局线程函数，传递this指针进去，再在全局线程函数中得到这个指针调用成员函数，并没实现真正的封装。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/ringphone/archive/2004/10/18/141074.aspx