MFC源码学习，为什么_AFX_THREAD_STATE *pState=_afxThreadState

        看过深入浅出MFC，但还是一知半解，有些细节还需得自已敲下代码，才能理解得深刻，这两天看MFC源代码，看到_AFX_THREAD_STATE *pState=_afxThreadState 时觉得很奇怪，怎么_AFX_THREAD_STATE类型指针能等于一个CThreadLocal类对象呢？

        _afxThreadState是由EXTERN_THREAD_LOCAL(_AFX_THREAD_STATE, _afxThreadState)   

#define EXTERN_THREAD_LOCAL(class_name, ident_name) extern CThreadLocal<class_name> ident_name;等宏、类定义语句得到的一个CThreadLocal类型的对象

       最后先是自已敲了代码，就跟想象的一样，编译出错，提示类弄转换出错，后来把MFC源代码删减了一些，复制到我的工程里，咦，很奇怪的事发生了，编译成功了。经过翻看c++primer 找出了原因。还是要把基础打好了，把c++ primer 多看几遍，光看c++ primer不行，还得和MFC源代码一起看，并敲下代码，才有好的效果，

MFC源代码从下图语句开始：         

extern "C" int WINAPI
_tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
_In_ LPTSTR lpCmdLine, int nCmdShow)
#pragma warning(suppress: 4985)
{
// call shared/exported WinMain
return AfxWinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow);
}

到

int AFXAPI AfxWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
	_In_ LPTSTR lpCmdLine, int nCmdShow)
{
	ASSERT(hPrevInstance == NULL);

	int nReturnCode = -1;
	CWinThread* pThread = AfxGetThread();
	CWinApp* pApp = AfxGetApp();

	// AFX internal initialization
	if (!AfxWinInit(hInstance, hPrevInstance, lpCmdLine, nCmdShow))
		goto InitFailure;

	// App global initializations (rare)
	if (pApp != NULL && !pApp->InitApplication())
		goto InitFailure;

	// Perform specific initializations
	if (!pThread->InitInstance())
	{
		if (pThread->m_pMainWnd != NULL)
		{
			TRACE(traceAppMsg, 0, "Warning: Destroying non-NULL m_pMainWnd\n");
			pThread->m_pMainWnd->DestroyWindow();
		}
		nReturnCode = pThread->ExitInstance();
		goto InitFailure;
	}
	nReturnCode = pThread->Run();

InitFailure:
#ifdef _DEBUG
	// Check for missing AfxLockTempMap calls
	if (AfxGetModuleThreadState()->m_nTempMapLock != 0)
	{
		TRACE(traceAppMsg, 0, "Warning: Temp map lock count non-zero (%ld).\n",
			AfxGetModuleThreadState()->m_nTempMapLock);
	}
	AfxLockTempMaps();
	AfxUnlockTempMaps(-1);
#endif

	AfxWinTerm();
	return nReturnCode;
}

_AFXWIN_INLINE CWinApp* AFXAPI AfxGetApp()
	{ return afxCurrentWinApp; }

#define afxCurrentWinApp    AfxGetModuleState()->m_pCurrentWinApp

AFX_MODULE_STATE* AFXAPI AfxGetModuleState()
{
	_AFX_THREAD_STATE* pState = _afxThreadState;
	ENSURE(pState);
	AFX_MODULE_STATE* pResult;
	if (pState->m_pModuleState != NULL)
	{
		// thread state's module state serves as override
		pResult = pState->m_pModuleState;
	}
	else
	{
		// otherwise, use global app state
		pResult = _afxBaseModuleState.GetData();
	}
	ENSURE(pResult != NULL);
	return pResult;
}

CThreadLocal是一个模板类，_afxThreadState是它的一个对象

CThreadLocal类的定义和声明如下：

template<class TYPE>
class CThreadLocal : public CThreadLocalObject
{
// Attributes
public:
	AFX_INLINE TYPE* GetData()
	{
		TYPE* pData = (TYPE*)CThreadLocalObject::GetData(&CreateObject);
		ENSURE(pData != NULL);
		return pData;
	}
	AFX_INLINE TYPE* GetDataNA()
	{
		TYPE* pData = (TYPE*)CThreadLocalObject::GetDataNA();
		return pData;
	}
	AFX_INLINE operator TYPE*()
	{ 
		return GetData(); 
	}
	AFX_INLINE TYPE* operator->()
	{ 
		return GetData(); 
	}

// Implementation
public:
	static CNoTrackObject* AFXAPI CreateObject()
		{ return new TYPE; }
};

              一直到这里，可以看出_AFX_THREAD_STATE *pState=_afxThreadState，就是_AFX_THREAD_STATE类型指针等于一个CThreadLocal类对象??为什么会是这样的？？

             带着疑问，自已敲了如下段代码在VC++里，看能不能编译通过：

#include <iostream>
using namespace std;
class a
{
public:
	a();
	virtual ~a();

	
	int i;

};
a::a()
{
	i=1;
	cout<<"a构造函数"<<endl;
}
a::~a()
{
}

template<class TYPE>
class b
{
// Attributes
public:
	b()
	{
		cout<<"b 构造函数"<<endl;
	}
	TYPE* GetData()
	{
		TYPE* p = CreateObject();
		
		return p;
	}
public:
	static TYPE * CreateObject()
		{ return new TYPE; }
};

b<a> _c;
void main()
{
a* pState =_c;
}

提示出错：cannot convert from 'class b<class a>' to 'class a *'，不能把class b<class a> 转换为class a

最后复制MFC源码，并删减了一些到自已的工程里如下：

#include <iostream>
using namespace std;
class _AFX_THREAD_STATE
{
public:
	_AFX_THREAD_STATE();
	virtual ~_AFX_THREAD_STATE();

	
	int m_pWndInit;

};
_AFX_THREAD_STATE::_AFX_THREAD_STATE()
{
	m_pWndInit=1;
	cout<<"_AFX_THREAD_STATE 构造函数"<<endl;
}
_AFX_THREAD_STATE::~_AFX_THREAD_STATE()
{
}

template<class TYPE>
class CThreadLocal
{
// Attributes
public:
	CThreadLocal()
	{
		cout<<"CThreadLocal 构造函数"<<endl;
	}
	TYPE* GetData()
	{
		TYPE* pData = CreateObject();
		
		return pData;
	}
	
	operator TYPE*()
		{ return GetData(); }
	TYPE* operator->()
		{ return GetData(); }

// Implementation
public:
	static TYPE * CreateObject()
		{ return new TYPE; }
};
//#define THREAD_LOCAL(class_name, ident_name) \
	//CThreadLocal<class_name> ident_name;
//THREAD_LOCAL(_AFX_THREAD_STATE, _afxThreadState)
CThreadLocal<_AFX_THREAD_STATE> _afxThreadState;
void main()
{
_AFX_THREAD_STATE* pState = (_AFX_THREAD_STATE*)_afxThreadState;
	//cout<<pState->m_pWndInit<<endl;
}

这份代码与我的代码有一点不同就是有operator type *(){return GetData();}

带着疑问，翻开了c++ primer 类类型转换一节，仔细看了一遍，原来是类里定义的operator type *()是类类型转换，这样做可以使类对象用于需要type*类型的任何地方。