大华相机中的一个模板嵌套

CSingleDisplayDlg::CSingleDisplayDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CSingleDisplayDlg::IDD, pParent)
	, _connected(false)
	, _isGrabbing(false)
	, _bRunning(false)
	, _frameCnt(0)
	, _frameCtrl(false)
	, _maxFrameCnt(0)
	, _devListDlg(NULL)
	, _displayThread(CThreadLite::ThreadProc(&CSingleDisplayDlg::DisplayThreadProc, this), "Display")
//	, _streamRetrieveThread(CThreadLite::ThreadProc(&CSingleDisplayDlg::StreamRetrieveThreadPro, this), "StreamRetrieve")
	, m_dDisplayInterval(0)
	, m_nFirstFrameTime(0)
	, m_nLastFrameTime(0)
	, m_strPortNum(_T(""))
	, m_strEditReceive(_T(""))
	, m_editCCD_Receive(_T(""))
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
	valMin = 0;
	frmCnt = 0;
	strFilePath = "";
	//setDisplayFPS(100);   // 默认显示30帧
}

上面的初始化列表中有：

_displayThread(CThreadLite::ThreadProc(&CSingleDisplayDlg::DisplayThreadProc, this), "Display")

DisplayThreadProc函数定义如下

// 显示线程
void CSingleDisplayDlg::DisplayThreadProc(Dahua::Infra::CThreadLite& lite)
{
	while ( lite.looping() )
	{
		
		if(!_bRunning)
		{
			Sleep(10);
			continue;
		}

		if(m_bStopGrabbing)
		{
			StopStreamGrabbing();
		}
		
		FrameBufferSPtr	displayFrame = getConvertedImage();
		
		if (!displayFrame )
		{
			continue;
		}

		_render.display(displayFrame->bufPtr(), displayFrame->Width(), displayFrame->Height(), displayFrame->PixelFormat());
	}
}

下面深入展开_displayThread(CThreadLite::ThreadProc(&CSingleDisplayDlg::DisplayThreadProc, this), "Display")

_displayThread的定义：

Dahua::Infra::CThreadLite           _displayThread;   // 显示线程

CThreadLite是一个继承自CThread的线程类

class INFRA_API CThreadLite : public CThread
{
	CThreadLite(CThreadLite const&);
	CThreadLite& operator=(CThreadLite const&);

public:
	/// 线程执行体, 参数为线程对象的引用
	typedef TFunction1<void, CThreadLite&> ThreadProc;

	/// 构造函数，并没有创建系统线程
	/// \param proc 线程体函数
	/// \param name 线程名称字符串，名称不一定会传给操作系统，但CThreadManager
	///		   管理线程时会用到。
	/// \param priority 线程优先级，值越小表示优先级越高，会被转化成对应操作系统
	///        平台的优先级。取值priorTop到priorBottom，默认值priorDefault。
	/// \param policy 线程调度策略
	/// \param stackSize 为线程指定的堆栈大小，如果等于0或者小于平台要求必须的值，
	///        则使用平台缺省值。
	CThreadLite(ThreadProc proc, const char* name, int priority = priorDefault, int policy = policyNormal, int stackSize = 0);

	/// 析构函数，如果线程还在执行，会销毁线程
	virtual ~CThreadLite();

private:
	/// 线程执行体
	virtual void threadProc();

	ThreadLiteInternal	*m_internal;
};

ThreadProc是一个类模板，第一个参数类型为void，第二个参数类型为CThreadLite&

//TFuction1
#define FUNCTION_NUMBER 1
#define FUNCTION_CLASS_TYPES typename R, typename T1
#define FUNCTION_TYPES T1
#define FUNCTION_TYPE_ARGS T1 a1
#define FUNCTION_ARGS a1
#include "FunctionTemplate.h"
#undef  FUNCTION_NUMBER
#undef  FUNCTION_CLASS_TYPES
#undef    FUNCTION_TYPES
#undef    FUNCTION_TYPE_ARGS
#undef    FUNCTION_ARGS

template <FUNCTION_CLASS_TYPES>
class FUNCTION_FUNCTION
{
	class X{};
	
	typedef R (X::*MEM_FUNCTION)(FUNCTION_TYPES);
	
	typedef R (*GEN_FUNCTION)(FUNCTION_TYPES);
	
	
	enum {
		MEMBER_SHAREDPTR_FUNC,
		MEMBER_OBJ_FUNC,
		GEN_FUNC,
		INVALID_FUNC
	};
	
	int m_type;
	
	union {
		MEM_FUNCTION memberFunc;
		GEN_FUNCTION genFunc;
	}m_f;
	X*                      m_obj;
	Memory::TSharedPtr< X > m_sptr;
	
public:
	
	/// 缺省构造函数
	FUNCTION_FUNCTION()
		: m_type(INVALID_FUNC)
		, m_obj(NULL)
	{
		m_f.memberFunc = NULL;
		m_f.genFunc	= NULL;
	}

	template< class T >
	FUNCTION_FUNCTION( R(T::*f)(FUNCTION_TYPES), Memory::TSharedPtr< T > const& object )
		: m_type(MEMBER_SHAREDPTR_FUNC)
		, m_obj(NULL)
		, m_sptr(object, Detail::horrible_cast<X*, T*>(object.get()))
	{
		m_f.memberFunc = Detail::horrible_cast<MEM_FUNCTION>(f);
	}

	
	template< class T >
	FUNCTION_FUNCTION( R(T::*f)(FUNCTION_TYPES), T* object )
		: m_type(MEMBER_OBJ_FUNC)
		, m_obj( Detail::horrible_cast<X*, T*>(object) )
	{
		m_f.memberFunc = Detail::horrible_cast<MEM_FUNCTION>(f);
	}
...
}

因此上面的模板类变为

R==>void    T1==>CThreadLite&
template <typename R, typename T1>
class TFunction1
{
	class X{};
	
	typedef void (X::*MEM_FUNCTION)(T1);
	
	typedef void (*GEN_FUNCTION)(T1);
	
	
	enum {
		MEMBER_SHAREDPTR_FUNC,
		MEMBER_OBJ_FUNC,
		GEN_FUNC,
		INVALID_FUNC
	};
	
	int m_type;
	
	union {
		MEM_FUNCTION memberFunc;
		GEN_FUNCTION genFunc;
	}m_f;
	X*                      m_obj;
	Memory::TSharedPtr< X > m_sptr;
	
public:
	
	/// 缺省构造函数
	TFunction1()
		: m_type(INVALID_FUNC)
		, m_obj(NULL)
	{
		m_f.memberFunc = NULL;
		m_f.genFunc	= NULL;
	}

	template< class T >
	TFunction1( R(T::*f)(T1), Memory::TSharedPtr< T > const& object )
		: m_type(MEMBER_SHAREDPTR_FUNC)
		, m_obj(NULL)
		, m_sptr(object, Detail::horrible_cast<X*, T*>(object.get()))
	{
		m_f.memberFunc = Detail::horrible_cast<MEM_FUNCTION>(f);
	}
...
}

CThreadLite::ThreadProc(&CSingleDisplayDlg::DisplayThreadProc, this)会调用构造函数

template< class T >
	FUNCTION_FUNCTION( R(T::*f)(FUNCTION_TYPES), T* object )
		: m_type(MEMBER_OBJ_FUNC)
		, m_obj( Detail::horrible_cast<X*, T*>(object) )
	{
		m_f.memberFunc = Detail::horrible_cast<MEM_FUNCTION>(f);
	}

默认推导T为CSingleDisplayDlg类，FUNCTION_TYPES为T1，即CThreadLite&，这是一个线程指向线程的引用，指向显示线程函数