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*类型的任何地方。