在我的那篇《讓程式在崩潰時體面的退出之Unhandled Exception》中提供了一個捕捉程式崩潰事件的方法，可以新增程式碼在程式崩潰的時候做出適當的處理。不過，只知道程式在什麼時候崩潰，但是不知道為什麼崩潰，這對於程式開發者來說沒有任何意義。因為如果不知道程式崩潰的原因，就沒法去找到程式碼中的缺陷，當然就沒法去修改程式碼而避免程式的崩潰。
        所有除錯過程式碼的開發者都知道CallStack的重要性。如果在程式崩潰的時候得到CallStack，那麼就能定位程式崩潰的具體位置，並最終找到解決方法。那麼有沒有什麼方法在程式崩潰的時候得到CallStack呢？答案是肯定的。微軟提供了一個DbgHelp.dll，裡面包含了一系列的Windows API來供開發者呼叫。它是一個除錯跟蹤相關的模組，用於跟蹤程序工作，在程序崩潰時收集程式產生異常時的堆疊資訊，以供開發人員分析，從而很快找出使程式出現異常的原因。
        下面用具體的例子程式碼來說明怎樣使用DbgHelp.dll中的Windows API來得到CallStack。程式碼裡面有詳細的註釋來幫助理解。
        用VC建立一個名為Test的控制檯程式，新增下面的程式碼。

// 一個有函式呼叫的類
// 
class CrashTest
{
public:
	void Test() 
	{ 
		Crash(); 
	}

private:
	void Crash() 
	{ 
		// 除零，人為的使程式崩潰
		//
		int i = 13;
		int j = 0;
		int m = i / j;
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	CrashTest test;
	test.Test();

	return 0;
}

        編譯上面的程式碼，到工程的Debug目錄下找到編譯好的Test.exe，雙擊執行，程式就會崩潰。從程式碼我們知道函式呼叫順序是main() -> CrashTest::Test() -> CrashTest::Crash()。那麼怎麼在程式崩潰的時候得到CallStack呢？首先，先新增一些工具函式。

#include <Windows.h>
#include <DbgHelp.h>
#include <iostream>
#include <vector>

// 新增對dbghelp.lib的編譯依賴
//
#pragma comment(lib, "dbghelp.lib")

using namespace std;

const int MAX_ADDRESS_LENGTH = 32;
const int MAX_NAME_LENGTH = 1024;

// 崩潰資訊
// 
struct CrashInfo
{
	CHAR ErrorCode[MAX_ADDRESS_LENGTH];
	CHAR Address[MAX_ADDRESS_LENGTH];
	CHAR Flags[MAX_ADDRESS_LENGTH];
};

// CallStack資訊
// 
struct CallStackInfo
{
	CHAR ModuleName[MAX_NAME_LENGTH];
	CHAR MethodName[MAX_NAME_LENGTH];
	CHAR FileName[MAX_NAME_LENGTH];
	CHAR LineNumber[MAX_NAME_LENGTH];
};

// 安全拷貝字串函式
//
void SafeStrCpy(char* szDest, size_t nMaxDestSize, const char* szSrc)
{
	if (nMaxDestSize <= 0) return;
	if (strlen(szSrc) < nMaxDestSize)
	{
		strcpy_s(szDest, nMaxDestSize, szSrc);
	}
	else
	{
		strncpy_s(szDest, nMaxDestSize, szSrc, nMaxDestSize);
		szDest[nMaxDestSize-1] = '\0';
	}
}  

// 得到程式崩潰資訊
//
CrashInfo GetCrashInfo(const EXCEPTION_RECORD *pRecord)
{
	CrashInfo crashinfo;
	SafeStrCpy(crashinfo.Address, MAX_ADDRESS_LENGTH, "N/A");
	SafeStrCpy(crashinfo.ErrorCode, MAX_ADDRESS_LENGTH, "N/A");
	SafeStrCpy(crashinfo.Flags, MAX_ADDRESS_LENGTH, "N/A");

	sprintf_s(crashinfo.Address, "%08X", pRecord->ExceptionAddress);
	sprintf_s(crashinfo.ErrorCode, "%08X", pRecord->ExceptionCode);
	sprintf_s(crashinfo.Flags, "%08X", pRecord->ExceptionFlags);

	return crashinfo;
}

// 得到CallStack資訊
//
vector<CallStackInfo> GetCallStack(const CONTEXT *pContext)
{
	HANDLE hProcess = GetCurrentProcess();

	SymInitialize(hProcess, NULL, TRUE);

	vector<CallStackInfo> arrCallStackInfo;

	CONTEXT c = *pContext;

	STACKFRAME64 sf;
	memset(&sf, 0, sizeof(STACKFRAME64));
	DWORD dwImageType = IMAGE_FILE_MACHINE_I386;

	// 不同的CPU型別，具體資訊可查詢MSDN
	//
#ifdef _M_IX86
	sf.AddrPC.Offset = c.Eip;
	sf.AddrPC.Mode = AddrModeFlat;
	sf.AddrStack.Offset = c.Esp;
	sf.AddrStack.Mode = AddrModeFlat;
	sf.AddrFrame.Offset = c.Ebp;
	sf.AddrFrame.Mode = AddrModeFlat;
#elif _M_X64
	dwImageType = IMAGE_FILE_MACHINE_AMD64;
	sf.AddrPC.Offset = c.Rip;
	sf.AddrPC.Mode = AddrModeFlat;
	sf.AddrFrame.Offset = c.Rsp;
	sf.AddrFrame.Mode = AddrModeFlat;
	sf.AddrStack.Offset = c.Rsp;
	sf.AddrStack.Mode = AddrModeFlat;
#elif _M_IA64
	dwImageType = IMAGE_FILE_MACHINE_IA64;
	sf.AddrPC.Offset = c.StIIP;
	sf.AddrPC.Mode = AddrModeFlat;
	sf.AddrFrame.Offset = c.IntSp;
	sf.AddrFrame.Mode = AddrModeFlat;
	sf.AddrBStore.Offset = c.RsBSP;
	sf.AddrBStore.Mode = AddrModeFlat;
	sf.AddrStack.Offset = c.IntSp;
	sf.AddrStack.Mode = AddrModeFlat;
#else
	#error "Platform not supported!"
#endif

	HANDLE hThread = GetCurrentThread();

	while (true)
	{
		// 該函式是實現這個功能的最重要的一個函式
		// 函式的用法以及引數和返回值的具體解釋可以查詢MSDN
		//
		if (!StackWalk64(dwImageType, hProcess, hThread, &sf, &c, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL))
		{
			break;
		}

		if (sf.AddrFrame.Offset == 0)
		{
			break;
		}
				
		CallStackInfo callstackinfo;
		SafeStrCpy(callstackinfo.MethodName, MAX_NAME_LENGTH, "N/A");
		SafeStrCpy(callstackinfo.FileName, MAX_NAME_LENGTH, "N/A");
		SafeStrCpy(callstackinfo.ModuleName, MAX_NAME_LENGTH, "N/A");
		SafeStrCpy(callstackinfo.LineNumber, MAX_NAME_LENGTH, "N/A");

		BYTE symbolBuffer[sizeof(IMAGEHLP_SYMBOL64) + MAX_NAME_LENGTH];
		IMAGEHLP_SYMBOL64 *pSymbol = (IMAGEHLP_SYMBOL64*)symbolBuffer;
		memset(pSymbol, 0, sizeof(IMAGEHLP_SYMBOL64) + MAX_NAME_LENGTH);

		pSymbol->SizeOfStruct = sizeof(symbolBuffer);
		pSymbol->MaxNameLength = MAX_NAME_LENGTH;

		DWORD symDisplacement = 0;
		
		// 得到函式名
		//
		if (SymGetSymFromAddr64(hProcess, sf.AddrPC.Offset, NULL, pSymbol))
		{
			SafeStrCpy(callstackinfo.MethodName, MAX_NAME_LENGTH, pSymbol->Name);
		}

		IMAGEHLP_LINE64 lineInfo;
		memset(&lineInfo, 0, sizeof(IMAGEHLP_LINE64));

		lineInfo.SizeOfStruct = sizeof(IMAGEHLP_LINE64);

		DWORD dwLineDisplacement;

		// 得到檔名和所在的程式碼行
		//
		if (SymGetLineFromAddr64(hProcess, sf.AddrPC.Offset, &dwLineDisplacement, &lineInfo))
		{
			SafeStrCpy(callstackinfo.FileName, MAX_NAME_LENGTH, lineInfo.FileName);
			sprintf_s(callstackinfo.LineNumber, "%d", lineInfo.LineNumber);
		}

		IMAGEHLP_MODULE64 moduleInfo;
		memset(&moduleInfo, 0, sizeof(IMAGEHLP_MODULE64));

		moduleInfo.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);

		// 得到模組名
		//
		if (SymGetModuleInfo64(hProcess, sf.AddrPC.Offset, &moduleInfo))
		{
			SafeStrCpy(callstackinfo.ModuleName, MAX_NAME_LENGTH, moduleInfo.ModuleName);
		}

		arrCallStackInfo.push_back(callstackinfo);
	}

	SymCleanup(hProcess);

	return arrCallStackInfo;
}
 

        然後，就可以用《讓程式在崩潰時體面的退出之Unhandled Exception》中提供的捕捉程式崩潰事件的方法新增一個回撥函式，在這個函式裡面呼叫上面的函式來得到程式崩潰時的CallStack。

// 處理Unhandled Exception的回撥函式
//
LONG ApplicationCrashHandler(EXCEPTION_POINTERS *pException)
{	
	// 確保有足夠的棧空間
	//
#ifdef _M_IX86
	if (pException->ExceptionRecord->ExceptionCode == EXCEPTION_STACK_OVERFLOW)
	{
		static char TempStack[1024 * 128];
		__asm mov eax,offset TempStack[1024 * 128];
		__asm mov esp,eax;
	}
#endif	

	CrashInfo crashinfo = GetCrashInfo(pException->ExceptionRecord);

	// 輸出Crash資訊
	//
	cout << "ErrorCode: " << crashinfo.ErrorCode << endl;
	cout << "Address: " << crashinfo.Address << endl;
	cout << "Flags: " << crashinfo.Flags << endl;
	
	vector<CallStackInfo> arrCallStackInfo = GetCallStack(pException->ContextRecord);

	// 輸出CallStack
	//
	cout << "CallStack: " << endl;
	for (vector<CallStackInfo>::iterator i = arrCallStackInfo.begin(); i != arrCallStackInfo.end(); ++i)
	{
		CallStackInfo callstackinfo = (*i);

		cout << callstackinfo.MethodName << "() : [" << callstackinfo.ModuleName << "] (File: " << callstackinfo.FileName << " @Line " << callstackinfo.LineNumber << ")" << endl;
	}

	// 這裡彈出一個錯誤對話方塊並退出程式
	//
	FatalAppExit(-1,  _T("*** Unhandled Exception! ***"));

	return EXCEPTION_EXECUTE_HANDLER;
}

        最後，在main函式的開頭新增下面的程式碼。

// 設定處理Unhandled Exception的回撥函式
// 
SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)ApplicationCrashHandler); 

        編譯上面的程式碼，到工程的Debug目錄下找到編譯好的Test.exe，雙擊執行，程式在崩潰的時候就會輸出CallStack。