思享工具箱

让程序在崩溃时体面的退出转

摘要：
viewplainint_Tmain｛__try｛MessageBox；//除以零，人为地使程序崩溃//int i=13；int j=0；int m=i/j；｝__最后｛//在此处添加处理程序崩溃的代码///以弹出对话框为例//MessageBox；｝MessageBox；return0；｝编译上述代码。单击“确定”按钮后，程序将正常退出。通过使用__try/__Exception可以捕获任何类型的异常，并确保程序不会崩溃！（想想它有多神奇。程序永远不会崩溃！如果高级代码没有异常捕获机制，程序将崩溃。exception_EXECUTE_HANDLER异常已处理，程序将在稍后继续执行。只要正确使用SEH，就有可能编写永远不会崩溃的应用程序。

转自 http://blog.csdn.net/starlee/article/details/6630816

让程序在崩溃时体面的退出之SEH

 SEH的全称是Structured Exception Handling，是Windows操作系统提供的一种异常处理方式。SEH是属于操作系统的特性，不为特定语言设计，从它的名字就能看出它是一种结构化的异常处理方式。SEH包括了2个部分：终止处理__try/__finally和异常处理__try/__except，下面分别进行介绍。

        终止处理__try/__finally
        __try/__finally可以保证无论try块内的代码执行结果如何，finally块内的代码总会被调用和执行。现在用下面的这个VC++中的控制台程序来说明。

  1. int _tmain(int argc, _TCHAR* argv[])  
  2. {  
  3.     __try  
  4.     {  
  5.         MessageBox(NULL, _T("Message from '__try' section"), _T("Test"), MB_OK);  
  6.   
  7.         // 除零，人为的使程序崩溃  
  8.         //  
  9.         int i = 13;  
  10.         int j = 0;  
  11.         int m = i / j;  
  12.     }  
  13.     __finally  
  14.     {  
  15.         // 在这里添加处理程序崩溃情况的代码  
  16.         //  
  17.   
  18.         // 这里以弹出一个对话框为例子  
  19.         //  
  20.         MessageBox(NULL, _T("Message from '__finally' section"), _T("Test"), MB_OK);  
  21.     }  
  22.   
  23.     MessageBox(NULL, _T("Funcation completed"), _T("Test"), MB_OK);  
  24.   
  25.     return 0;  
  26. }  

        编译上面的代码。运行生成的EXE，会弹出下面的对话框。

让程序在崩溃时体面的退出转第1张

        点击OK按钮后，程序会崩溃。

让程序在崩溃时体面的退出转第2张

        在出现上面这个对话框的时候点击Cancel，将控制权返还给程序，那么下面的对话框就会弹出。

让程序在崩溃时体面的退出转第3张

        点击OK按钮后，程序正常退出。
        由上面的例子可以看出，无论try块中的代码会不会出现异常，在程序终止的时候，finally块中的代码都会被调用和执行。所以一般情况下，finally块中的代码都是用来做一些清理工作和资源的释放。

        异常处理__try/__except
        __try/__except是用来捕捉异常的，只有当try块中的代码出现异常的时候，except块中的代码才会被调用和执行。它的语法是这样的：

  1. __try  
  2. {  
  3.     // guarded code  
  4. }  
  5. __except(expression)  
  6. {  
  7.      // exception handler code  
  8. }  

        它最大的一个好处就是可以完全控制异常进程。expression的值决定了异常被处理完后，进程该如何执行。下面依然用VC++中的控制台程序来说明。

  1. int _tmain(int argc, _TCHAR* argv[])  
  2. {  
  3.     __try  
  4.     {  
  5.         MessageBox(NULL, _T("Message from '__try' section"), _T("Test"), MB_OK);  
  6.   
  7.         // 除零，人为的使程序崩溃  
  8.         //  
  9.         int i = 13;  
  10.         int j = 0;  
  11.         int m = i / j;  
  12.     }  
  13.     __except(EXCEPTION_EXECUTE_HANDLER)  
  14.     {  
  15.         // 在这里添加处理程序崩溃情况的代码  
  16.         //  
  17.   
  18.         // 这里以弹出一个对话框为例子  
  19.         //  
  20.         MessageBox(NULL, _T("Message from '__except' section"), _T("Test"), MB_OK);  
  21.     }  
  22.   
  23.     MessageBox(NULL, _T("Funcation completed"), _T("Test"), MB_OK);  
  24.   
  25.     return 0;  
  26. }  

        编译上面的代码。运行生成的EXE，会依次弹出下面的对话框。

让程序在崩溃时体面的退出转第1张让程序在崩溃时体面的退出转第5张让程序在崩溃时体面的退出转第6张

        可以看出，在异常处理代码被调用执行后（except块中的代码），程序继续可以继续运行，并正常退出，并没有崩溃！通过使用__try/__except可以捕捉到任何类型的异常，并保证程序不会崩溃！（想想这是多么的神奇，一个程序永远不会崩溃！）
        下面解释一下except中表达式各个值的含义：

EXCEPTION_CONTINUE_SEARCH        异常没有被处理，继续向上抛出。如果更上层的代码没有异常捕捉机制，程序就会崩溃。
EXCEPTION_CONTINUE_EXECUTION   异常已经被处理，返回异常发生的地方继续执行。
EXCEPTION_EXECUTE_HANDLER        异常已经被处理，程序继续往后执行。

        通过上面的例子可以知道，SEH的异常处理跟C++的异常处理不同，C++的try/catch不能控制异常进程，对于异常，要么处理，要么继续向上抛出。而SEH却能完全控制异常进程，处理完异常之后，还能决定进该进程如何执行。只要SEH运用得当，编写一个永不崩溃的应用程序成为可能。但是SEH有一个致命的弱点，那就是它是一种结构化的异常处理，所以不支持面向对象。下面用具体的VC++控制台程序来说明。

  1. // 一个有函数调用的类  
  2. //   
  3. class CrashTest  
  4. {  
  5. public:  
  6.     CrashTest() {}  
  7.     ~CrashTest() {}  
  8.   
  9.     void Test()   
  10.     {   
  11.         Crash();   
  12.     }  
  13.   
  14. private:  
  15.     void Crash()   
  16.     {   
  17.         // 除零，人为的使程序崩溃  
  18.         //  
  19.         int i = 13;  
  20.         int j = 0;  
  21.         int m = i / j;  
  22.     }  
  23. };  
  24.   
  25. int _tmain(int argc, _TCHAR* argv[])  
  26. {  
  27.     __try  
  28.     {  
  29.         CrashTest test;  
  30.         test.Test();  
  31.     }  
  32.     __except(EXCEPTION_EXECUTE_HANDLER)  
  33.     {  
  34.         // 在这里添加处理程序崩溃情况的代码  
  35.         //  
  36.     }  
  37.   
  38.     return 0;  
  39. }  

        上面的代码不能通过编译，VC++编译器会给出这样的错误信息：error C2712: Cannot use __try in functions that require object unwinding。错误原因很简单，try块内使用了对象。
        要想解决这个问题，可以把使用对象的逻辑放到一个函数里，然后在try里调用这个函数，来骗过编译器。把上面的代码修改成下面这样就可以通过编译。

  1. void Test()  
  2. {  
  3.     CrashTest test;  
  4.     test.Test();  
  5. }  
  6.   
  7. int _tmain(int argc, _TCHAR* argv[])  
  8. {  
  9.     __try  
  10.     {  
  11.         Test();  
  12.     }  
  13.     __except(EXCEPTION_EXECUTE_HANDLER)  
  14.     {  
  15.         // 在这里添加处理程序崩溃情况的代码  
  16.         //  
  17.     }  
  18.   
  19.     return 0;  
  20. }  


让程序在崩溃时体面的退出之Unhandled Exception

程序是由代码编译出来的，而代码是由人写的。人非圣贤，孰能无过。所以由人写的代码有缺陷是很正常的。当然很多异常都在开发阶段被考虑到而添加了处理代码，或者用try/catch对可能出现异常的地方进行额外的照顾。可是，还是会有一些无法预料的异常（Unhandled Exception）在程序运行的时候出现。这些异常很多时候都会招致程序的崩溃。那么有没有什么方法可以让程序在崩溃的时候体面的退出呢？答案是肯定的。可以用Windows API中的SetUnhandledExceptionFilter来设置一个回调函数来处理这些无法预料的异常。
        要想使用SetUnhandledExceptionFilter，必须#include <Windows.h>，这个函数的声明如下：

  1. LPTOP_LEVEL_EXCEPTION_FILTER WINAPI SetUnhandledExceptionFilter(  
  2.   __in  LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter  
  3. );  

        具体的参数和返回值的解释可以查找MSDN，有很详细的说明。下面就用具体的代码来说明怎样使用这个Windows API来使程序在崩溃的时候体面的退出。代码里面有详细的注释来帮助理解。
        用VC创建一个名为Test的控制台程序，添加下面的代码。

  1. #include "stdafx.h"  
  2.   
  3. int _tmain(int argc, _TCHAR* argv[])  
  4. {  
  5.     // 除零，人为的使程序崩溃  
  6.     //  
  7.     int i = 13;  
  8.     int j = 0;  
  9.     int k = i / j;  
  10.   
  11.     return 0;  
  12. }  

        编译上面的代码，到工程的Debug目录下找到编译好的Test.exe，双击运行，在Windows 7下就会出现下面的对话框告诉你程序无法运行，也就是崩溃了。

让程序在崩溃时体面的退出转第7张

        为了避免出现程序崩溃的情况，用前面所说的方法，把代码修改成下面这样。

  1. #include "stdafx.h"  
  2. #include <Windows.h>  
  3.   
  4. // 处理Unhandled Exception的回调函数  
  5. //  
  6. LONG ApplicationCrashHandler(EXCEPTION_POINTERS *pException)  
  7. {     
  8.     // 在这里添加处理程序崩溃情况的代码  
  9.     // 现在很多软件都是弹出一个发送错误报告的对话框  
  10.   
  11.     // 这里以弹出一个错误对话框并退出程序为例子  
  12.     //  
  13.     FatalAppExit(-1,  _T("*** Unhandled Exception! ***"));  
  14.   
  15.     return EXCEPTION_EXECUTE_HANDLER;  
  16. }  
  17.   
  18. int _tmain(int argc, _TCHAR* argv[])  
  19. {  
  20.     // 设置处理Unhandled Exception的回调函数  
  21.     //   
  22.     SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)ApplicationCrashHandler);   
  23.   
  24.     // 除零，人为的使程序崩溃  
  25.     //  
  26.     int i = 13;  
  27.     int j = 0;  
  28.     int k = i / j;  
  29.   
  30.     return 0;  
  31. }  

        编译上面的代码，到工程的Debug目录下找到编译好的Test.exe，双击运行，就会出现下面这样的对话框，点击OK按钮后，程序正常退出。

让程序在崩溃时体面的退出转第8张

让程序在崩溃时体面的退出之CallStack

在我的那篇《让程序在崩溃时体面的退出之Unhandled Exception》中提供了一个捕捉程序崩溃事件的方法，可以添加代码在程序崩溃的时候做出适当的处理。不过，只知道程序在什么时候崩溃，但是不知道为什么崩溃，这对于程序开发者来说没有任何意义。因为如果不知道程序崩溃的原因，就没法去找到代码中的缺陷，当然就没法去修改代码而避免程序的崩溃。
        所有调试过代码的开发者都知道CallStack的重要性。如果在程序崩溃的时候得到CallStack，那么就能定位程序崩溃的具体位置，并最终找到解决方法。那么有没有什么方法在程序崩溃的时候得到CallStack呢？答案是肯定的。微软提供了一个DbgHelp.dll，里面包含了一系列的Windows API来供开发者调用。它是一个调试跟踪相关的模块，用于跟踪进程工作，在进程崩溃时收集程序产生异常时的堆栈信息，以供开发人员分析，从而很快找出使程序出现异常的原因。
        下面用具体的例子代码来说明怎样使用DbgHelp.dll中的Windows API来得到CallStack。代码里面有详细的注释来帮助理解。
        用VC创建一个名为Test的控制台程序，添加下面的代码。

  1. // 一个有函数调用的类  
  2. //   
  3. class CrashTest  
  4. {  
  5. public:  
  6.     void Test()   
  7.     {   
  8.         Crash();   
  9.     }  
  10.   
  11. private:  
  12.     void Crash()   
  13.     {   
  14.         // 除零，人为的使程序崩溃  
  15.         //  
  16.         int i = 13;  
  17.         int j = 0;  
  18.         int m = i / j;  
  19.     }  
  20. };  
  21.   
  22. int _tmain(int argc, _TCHAR* argv[])  
  23. {  
  24.     CrashTest test;  
  25.     test.Test();  
  26.   
  27.     return 0;  
  28. }  

        编译上面的代码，到工程的Debug目录下找到编译好的Test.exe，双击运行，程序就会崩溃。从代码我们知道函数调用顺序是main() -> CrashTest::Test() -> CrashTest::Crash()。那么怎么在程序崩溃的时候得到CallStack呢？首先，先添加一些工具函数。

  1. #include <Windows.h>  
  2. #include <DbgHelp.h>  
  3. #include <iostream>  
  4. #include <vector>  
  5.   
  6. // 添加对dbghelp.lib的编译依赖  
  7. //  
  8. #pragma comment(lib, "dbghelp.lib")  
  9.   
  10. using namespace std;  
  11.   
  12. const int MAX_ADDRESS_LENGTH = 32;  
  13. const int MAX_NAME_LENGTH = 1024;  
  14.   
  15. // 崩溃信息  
  16. //   
  17. struct CrashInfo  
  18. {  
  19.     CHAR ErrorCode[MAX_ADDRESS_LENGTH];  
  20.     CHAR Address[MAX_ADDRESS_LENGTH];  
  21.     CHAR Flags[MAX_ADDRESS_LENGTH];  
  22. };  
  23.   
  24. // CallStack信息  
  25. //   
  26. struct CallStackInfo  
  27. {  
  28.     CHAR ModuleName[MAX_NAME_LENGTH];  
  29.     CHAR MethodName[MAX_NAME_LENGTH];  
  30.     CHAR FileName[MAX_NAME_LENGTH];  
  31.     CHAR LineNumber[MAX_NAME_LENGTH];  
  32. };  
  33.   
  34. // 安全拷贝字符串函数  
  35. //  
  36. void SafeStrCpy(char* szDest, size_t nMaxDestSize, const char* szSrc)  
  37. {  
  38.     if (nMaxDestSize <= 0) return;  
  39.     if (strlen(szSrc) < nMaxDestSize)  
  40.     {  
  41.         strcpy_s(szDest, nMaxDestSize, szSrc);  
  42.     }  
  43.     else  
  44.     {  
  45.         strncpy_s(szDest, nMaxDestSize, szSrc, nMaxDestSize);  
  46.         szDest[nMaxDestSize-1] = '\0';  
  47.     }  
  48. }    
  49.   
  50. // 得到程序崩溃信息  
  51. //  
  52. CrashInfo GetCrashInfo(const EXCEPTION_RECORD *pRecord)  
  53. {  
  54.     CrashInfo crashinfo;  
  55.     SafeStrCpy(crashinfo.Address, MAX_ADDRESS_LENGTH, "N/A");  
  56.     SafeStrCpy(crashinfo.ErrorCode, MAX_ADDRESS_LENGTH, "N/A");  
  57.     SafeStrCpy(crashinfo.Flags, MAX_ADDRESS_LENGTH, "N/A");  
  58.   
  59.     sprintf_s(crashinfo.Address, "%08X", pRecord->ExceptionAddress);  
  60.     sprintf_s(crashinfo.ErrorCode, "%08X", pRecord->ExceptionCode);  
  61.     sprintf_s(crashinfo.Flags, "%08X", pRecord->ExceptionFlags);  
  62.   
  63.     return crashinfo;  
  64. }  
  65.   
  66. // 得到CallStack信息  
  67. //  
  68. vector<CallStackInfo> GetCallStack(const CONTEXT *pContext)  
  69. {  
  70.     HANDLE hProcess = GetCurrentProcess();  
  71.   
  72.     SymInitialize(hProcess, NULL, TRUE);  
  73.   
  74.     vector<CallStackInfo> arrCallStackInfo;  
  75.   
  76.     CONTEXT c = *pContext;  
  77.   
  78.     STACKFRAME64 sf;  
  79.     memset(&sf, 0, sizeof(STACKFRAME64));  
  80.     DWORD dwImageType = IMAGE_FILE_MACHINE_I386;  
  81.   
  82.     // 不同的CPU类型，具体信息可查询MSDN  
  83.     //  
  84. #ifdef _M_IX86  
  85.     sf.AddrPC.Offset = c.Eip;  
  86.     sf.AddrPC.Mode = AddrModeFlat;  
  87.     sf.AddrStack.Offset = c.Esp;  
  88.     sf.AddrStack.Mode = AddrModeFlat;  
  89.     sf.AddrFrame.Offset = c.Ebp;  
  90.     sf.AddrFrame.Mode = AddrModeFlat;  
  91. #elif _M_X64  
  92.     dwImageType = IMAGE_FILE_MACHINE_AMD64;  
  93.     sf.AddrPC.Offset = c.Rip;  
  94.     sf.AddrPC.Mode = AddrModeFlat;  
  95.     sf.AddrFrame.Offset = c.Rsp;  
  96.     sf.AddrFrame.Mode = AddrModeFlat;  
  97.     sf.AddrStack.Offset = c.Rsp;  
  98.     sf.AddrStack.Mode = AddrModeFlat;  
  99. #elif _M_IA64  
  100.     dwImageType = IMAGE_FILE_MACHINE_IA64;  
  101.     sf.AddrPC.Offset = c.StIIP;  
  102.     sf.AddrPC.Mode = AddrModeFlat;  
  103.     sf.AddrFrame.Offset = c.IntSp;  
  104.     sf.AddrFrame.Mode = AddrModeFlat;  
  105.     sf.AddrBStore.Offset = c.RsBSP;  
  106.     sf.AddrBStore.Mode = AddrModeFlat;  
  107.     sf.AddrStack.Offset = c.IntSp;  
  108.     sf.AddrStack.Mode = AddrModeFlat;  
  109. #else  
  110.     #error "Platform not supported!"  
  111. #endif  
  112.   
  113.     HANDLE hThread = GetCurrentThread();  
  114.   
  115.     while (true)  
  116.     {  
  117.         // 该函数是实现这个功能的最重要的一个函数  
  118.         // 函数的用法以及参数和返回值的具体解释可以查询MSDN  
  119.         //  
  120.         if (!StackWalk64(dwImageType, hProcess, hThread, &sf, &c, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL))  
  121.         {  
  122.             break;  
  123.         }  
  124.   
  125.         if (sf.AddrFrame.Offset == 0)  
  126.         {  
  127.             break;  
  128.         }  
  129.                   
  130.         CallStackInfo callstackinfo;  
  131.         SafeStrCpy(callstackinfo.MethodName, MAX_NAME_LENGTH, "N/A");  
  132.         SafeStrCpy(callstackinfo.FileName, MAX_NAME_LENGTH, "N/A");  
  133.         SafeStrCpy(callstackinfo.ModuleName, MAX_NAME_LENGTH, "N/A");  
  134.         SafeStrCpy(callstackinfo.LineNumber, MAX_NAME_LENGTH, "N/A");  
  135.   
  136.         BYTE symbolBuffer[sizeof(IMAGEHLP_SYMBOL64) + MAX_NAME_LENGTH];  
  137.         IMAGEHLP_SYMBOL64 *pSymbol = (IMAGEHLP_SYMBOL64*)symbolBuffer;  
  138.         memset(pSymbol, 0, sizeof(IMAGEHLP_SYMBOL64) + MAX_NAME_LENGTH);  
  139.   
  140.         pSymbol->SizeOfStruct = sizeof(symbolBuffer);  
  141.         pSymbol->MaxNameLength = MAX_NAME_LENGTH;  
  142.   
  143.         DWORD symDisplacement = 0;  
  144.           
  145.         // 得到函数名  
  146.         //  
  147.         if (SymGetSymFromAddr64(hProcess, sf.AddrPC.Offset, NULL, pSymbol))  
  148.         {  
  149.             SafeStrCpy(callstackinfo.MethodName, MAX_NAME_LENGTH, pSymbol->Name);  
  150.         }  
  151.   
  152.         IMAGEHLP_LINE64 lineInfo;  
  153.         memset(&lineInfo, 0, sizeof(IMAGEHLP_LINE64));  
  154.   
  155.         lineInfo.SizeOfStruct = sizeof(IMAGEHLP_LINE64);  
  156.   
  157.         DWORD dwLineDisplacement;  
  158.   
  159.         // 得到文件名和所在的代码行  
  160.         //  
  161.         if (SymGetLineFromAddr64(hProcess, sf.AddrPC.Offset, &dwLineDisplacement, &lineInfo))  
  162.         {  
  163.             SafeStrCpy(callstackinfo.FileName, MAX_NAME_LENGTH, lineInfo.FileName);  
  164.             sprintf_s(callstackinfo.LineNumber, "%d", lineInfo.LineNumber);  
  165.         }  
  166.   
  167.         IMAGEHLP_MODULE64 moduleInfo;  
  168.         memset(&moduleInfo, 0, sizeof(IMAGEHLP_MODULE64));  
  169.   
  170.         moduleInfo.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);  
  171.   
  172.         // 得到模块名  
  173.         //  
  174.         if (SymGetModuleInfo64(hProcess, sf.AddrPC.Offset, &moduleInfo))  
  175.         {  
  176.             SafeStrCpy(callstackinfo.ModuleName, MAX_NAME_LENGTH, moduleInfo.ModuleName);  
  177.         }  
  178.   
  179.         arrCallStackInfo.push_back(callstackinfo);  
  180.     }  
  181.   
  182.     SymCleanup(hProcess);  
  183.   
  184.     return arrCallStackInfo;  
  185. }  

        然后，就可以用《让程序在崩溃时体面的退出之Unhandled Exception》中提供的捕捉程序崩溃事件的方法添加一个回调函数，在这个函数里面调用上面的函数来得到程序崩溃时的CallStack。

  1. // 处理Unhandled Exception的回调函数  
  2. //  
  3. LONG ApplicationCrashHandler(EXCEPTION_POINTERS *pException)  
  4. {     
  5.     // 确保有足够的栈空间  
  6.     //  
  7. #ifdef _M_IX86  
  8.     if (pException->ExceptionRecord->ExceptionCode == EXCEPTION_STACK_OVERFLOW)  
  9.     {  
  10.         static char TempStack[1024 * 128];  
  11.         __asm mov eax,offset TempStack[1024 * 128];  
  12.         __asm mov esp,eax;  
  13.     }  
  14. #endif    
  15.   
  16.     CrashInfo crashinfo = GetCrashInfo(pException->ExceptionRecord);  
  17.   
  18.     // 输出Crash信息  
  19.     //  
  20.     cout << "ErrorCode: " << crashinfo.ErrorCode << endl;  
  21.     cout << "Address: " << crashinfo.Address << endl;  
  22.     cout << "Flags: " << crashinfo.Flags << endl;  
  23.       
  24.     vector<CallStackInfo> arrCallStackInfo = GetCallStack(pException->ContextRecord);  
  25.   
  26.     // 输出CallStack  
  27.     //  
  28.     cout << "CallStack: " << endl;  
  29.     for (vector<CallStackInfo>::iterator i = arrCallStackInfo.begin(); i != arrCallStackInfo.end(); ++i)  
  30.     {  
  31.         CallStackInfo callstackinfo = (*i);  
  32.   
  33.         cout << callstackinfo.MethodName << "() : [" << callstackinfo.ModuleName << "] (File: " << callstackinfo.FileName << " @Line " << callstackinfo.LineNumber << ")" << endl;  
  34.     }  
  35.   
  36.     // 这里弹出一个错误对话框并退出程序  
  37.     //  
  38.     FatalAppExit(-1,  _T("*** Unhandled Exception! ***"));  
  39.   
  40.     return EXCEPTION_EXECUTE_HANDLER;  
  41. }  

        最后，在main函数的开头添加下面的代码。

  1. // 设置处理Unhandled Exception的回调函数  
  2. //   
  3. SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)ApplicationCrashHandler);   

        编译上面的代码，到工程的Debug目录下找到编译好的Test.exe，双击运行，程序在崩溃的时候就会输出CallStack。
让程序在崩溃时体面的退出转第9张

让程序在崩溃时体面的退出之Dump文件

  在我的那篇《让程序在崩溃时体面的退出之CallStack》中提供了一个在程序崩溃时得到CallStack的方法。可是要想得到CallStack，必须有pdb文件的支持。但是一般情况下，发布出去的程序都是Release版本的，都不会附带pdb文件。那么我们怎么能在程序崩溃的时候找到出错的具体位置呢？这个时候就该Dump文件出场了！Dump文件是进程的内存镜像，可以把程序运行时的状态完整的保存下来。 
        要想在程序崩溃的时候创建Dump文件，就需要用到DbgHelp.dll中Windows API的MiniDumpWriteDump()函数。该函数声明如下：

  1. BOOL WINAPI MiniDumpWriteDump(  
  2.   __in  HANDLE hProcess,  
  3.   __in  DWORD ProcessId,  
  4.   __in  HANDLE hFile,  
  5.   __in  MINIDUMP_TYPE DumpType,  
  6.   __in  PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,  
  7.   __in  PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,  
  8.   __in  PMINIDUMP_CALLBACK_INFORMATION CallbackParam  
  9. );  

        具体的参数和返回值的解释可以查找MSDN，有很详细的说明。下面依然用上一篇文章中的例子代码来说明怎么在程序崩溃的时候创建Dump文件。

  1. // 处理Unhandled Exception的回调函数  
  2. //  
  3. LONG ApplicationCrashHandler(EXCEPTION_POINTERS *pException)  
  4. {     
  5.     // 这里弹出一个错误对话框并退出程序  
  6.     //  
  7.     FatalAppExit(-1,  _T("*** Unhandled Exception! ***"));  
  8.   
  9.     return EXCEPTION_EXECUTE_HANDLER;  
  10. }  
  11.   
  12. // 一个有函数调用的类  
  13. //   
  14. class CrashTest  
  15. {  
  16. public:  
  17.     void Test()   
  18.     {   
  19.         Crash();   
  20.     }  
  21.   
  22. private:  
  23.     void Crash()   
  24.     {   
  25.         // 除零，人为的使程序崩溃  
  26.         //  
  27.         int i = 13;  
  28.         int j = 0;  
  29.         int m = i / j;  
  30.     }  
  31. };  
  32.   
  33. int _tmain(int argc, _TCHAR* argv[])  
  34. {  
  35.     // 设置处理Unhandled Exception的回调函数  
  36.     //   
  37.     SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)ApplicationCrashHandler);   
  38.   
  39.     CrashTest test;  
  40.     test.Test();  
  41.   
  42.     return 0;  
  43. }  

        在上面的程序崩溃的时候，会调用函数ApplicationCrashHandler()。创建Dump文件的代码就需要添加到该函数中。下面就是一个创建Dump文件的函数。

  1. // 创建Dump文件  
  2. //   
  3. void CreateDumpFile(LPCWSTR lpstrDumpFilePathName, EXCEPTION_POINTERS *pException)  
  4. {  
  5.     // 创建Dump文件  
  6.     //  
  7.     HANDLE hDumpFile = CreateFile(lpstrDumpFilePathName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);  
  8.   
  9.     // Dump信息  
  10.     //  
  11.     MINIDUMP_EXCEPTION_INFORMATION dumpInfo;  
  12.     dumpInfo.ExceptionPointers = pException;  
  13.     dumpInfo.ThreadId = GetCurrentThreadId();  
  14.     dumpInfo.ClientPointers = TRUE;  
  15.   
  16.     // 写入Dump文件内容  
  17.     //  
  18.     MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hDumpFile, MiniDumpNormal, &dumpInfo, NULL, NULL);  
  19.   
  20.     CloseHandle(hDumpFile);  
  21. }  

        在函数ApplicationCrashHandler()用类似下面的代码来调用上面的函数，就可以在程序崩溃的时候创建Dump文件。

  1. CreateDumpFile(_T("C:\\Test.dmp"), pException);  

        下面简单说一下Dump文件的用法。将Dump文件拷贝到含有应用程序和对应的pdb文件的目录，在VS里面打开Dump文件（或者直接双击Dump文件），VS会自动创建一个Solution，直接调试运行，代码就会停到使程序崩溃的那一行上。就跟在VS里面调试代码一摸一样。（VS2008）

让程序在崩溃时体面的退出转第10张
        在VS2010里打开Dump文件，会显示一个Minidump File Summary，并且可以进行下面图中的操作。

让程序在崩溃时体面的退出转第11张

 

让程序在崩溃时体面的退出之SEH+Dump文件

在我上篇文章《让程序在崩溃时体面的退出之SEH》中讲解了SEH中try/except可以捕捉异常，避免程序的崩溃，并且可以在处理完异常之后，还能决定进该进程如何执行。对于应用程序的使用者来说，并不知道异常的发生。但是对于软件的开发者来说，虽然避免了程序的崩溃，可是这样可以让程序崩溃的缺陷存在于代码中，就像一个定时炸弹，不知道什么时候会爆炸。要想修复这样的缺陷，首先要找到导致程序崩溃的那行代码。而我在我的那篇《让程序在崩溃时体面的退出之Dump文件》里面介绍了如何用Dump文件来定位使程序崩溃的代码。这里依然可以用同样的方法。下面就是创建Dump文件的函数。

  1. // 创建Dump文件  
  2. //   
  3. void CreateDumpFile(LPCWSTR lpstrDumpFilePathName, EXCEPTION_POINTERS *pException)  
  4. {  
  5.     // 创建Dump文件  
  6.     //  
  7.     HANDLE hDumpFile = CreateFile(lpstrDumpFilePathName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);  
  8.   
  9.     // Dump信息  
  10.     //  
  11.     MINIDUMP_EXCEPTION_INFORMATION dumpInfo;  
  12.     dumpInfo.ExceptionPointers = pException;  
  13.     dumpInfo.ThreadId = GetCurrentThreadId();  
  14.     dumpInfo.ClientPointers = TRUE;  
  15.   
  16.     // 写入Dump文件内容  
  17.     //  
  18.     MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hDumpFile, MiniDumpNormal, &dumpInfo, NULL, NULL);  
  19.   
  20.     CloseHandle(hDumpFile);  
  21. }  

       从上面的代码中可以看出，要想创建Dump文件，必须得到一个指向EXCEPTION_POINTERS结构的指针。怎么在try/except块中得到这个指针呢？这个时候就需要用到Windows API中的GetExceptionInformation()。这个函数的返回值就是一个指向EXCEPTION_POINTERS结构的指针。下面是具体的代码。

  1. // 作为except块中表达式的函数  
  2. //  
  3. LONG CrashHandler(EXCEPTION_POINTERS *pException)  
  4. {     
  5.     // 在这里添加处理程序崩溃情况的代码  
  6.     //  
  7.   
  8.     // 这里以弹出一个对话框为例子  
  9.     //  
  10.     MessageBox(NULL, _T("Message from Catch handler"), _T("Test"), MB_OK);  
  11.   
  12.     // 创建Dump文件  
  13.     //  
  14.     CreateDumpFile(_T("C:\\Test.dmp"), pException);  
  15.   
  16.     return EXCEPTION_EXECUTE_HANDLER;  
  17. }  
  18.   
  19. int _tmain(int argc, _TCHAR* argv[])  
  20. {  
  21.     __try  
  22.     {  
  23.         MessageBox(NULL, _T("Message from '__try' section"), _T("Test"), MB_OK);  
  24.   
  25.         // 除零，人为的使程序崩溃  
  26.         //  
  27.         int i = 13;  
  28.         int j = 0;  
  29.         int m = i / j;  
  30.     }  
  31.     // 捕捉到让程序崩溃的异常时创建Dump文件  
  32.     //  
  33.     __except(CrashHandler(GetExceptionInformation()))  
  34.     {  
  35.         // 这里以弹出一个对话框为例子  
  36.         //  
  37.         MessageBox(NULL, _T("Message from '__except' section"), _T("Test"), MB_OK);  
  38.     }  
  39.   
  40.     MessageBox(NULL, _T("Funcation completed"), _T("Test"), MB_OK);  
  41.   
  42.     return 0;  
  43. }  

        编译上面的代码并运行，会依次弹出下面这些对话框，并在C盘创建一个Dump文件Test.dmp。

让程序在崩溃时体面的退出转第1张让程序在崩溃时体面的退出转第13张让程序在崩溃时体面的退出转第5张让程序在崩溃时体面的退出转第6张

        有了Dump文件，就可以轻松定位使程序崩溃的那行代码，具体方法可参考我的《让程序在崩溃时体面的退出之Dump文件》。

让程序在崩溃时体面的退出之终极解决方案（SEH+Dump+Unhandled Exception Filter）

在我的上篇文章《让程序在崩溃时体面的退出之SEH+Dump文件》我介绍了怎样用SEH加上Dump文件来避免程序的崩溃并在程序崩溃时创建Dump文件来帮助定位出现异常的代码行。可是只有try/except块中try块中的代码出现异常才能被捕捉到，try块外面的代码出现异常，程序照样会崩溃。
        下面用《让程序在崩溃时体面的退出之SEH+Dump文件》文中的代码为例子来说明。

  1. // 创建Dump文件  
  2. //   
  3. void CreateDumpFile(LPCWSTR lpstrDumpFilePathName, EXCEPTION_POINTERS *pException)  
  4. {  
  5.     // 创建Dump文件  
  6.     //  
  7.     HANDLE hDumpFile = CreateFile(lpstrDumpFilePathName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);  
  8.   
  9.     // Dump信息  
  10.     //  
  11.     MINIDUMP_EXCEPTION_INFORMATION dumpInfo;  
  12.     dumpInfo.ExceptionPointers = pException;  
  13.     dumpInfo.ThreadId = GetCurrentThreadId();  
  14.     dumpInfo.ClientPointers = TRUE;  
  15.   
  16.     // 写入Dump文件内容  
  17.     //  
  18.     MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hDumpFile, MiniDumpNormal, &dumpInfo, NULL, NULL);  
  19.   
  20.     CloseHandle(hDumpFile);  
  21. }  
  22.   
  23. // 作为except块中表达式的函数  
  24. //  
  25. LONG CrashHandler(EXCEPTION_POINTERS *pException)  
  26. {     
  27.     // 在这里添加处理程序崩溃情况的代码  
  28.     //  
  29.   
  30.     // 这里以弹出一个对话框为例子  
  31.     //  
  32.     MessageBox(NULL, _T("Message from Catch handler"), _T("Test"), MB_OK);  
  33.   
  34.     // 创建Dump文件  
  35.     //  
  36.     CreateDumpFile(_T("C:\\Test.dmp"), pException);  
  37.   
  38.     return EXCEPTION_EXECUTE_HANDLER;  
  39. }  
  40.   
  41. int _tmain(int argc, _TCHAR* argv[])  
  42. {  
  43.     __try  
  44.     {  
  45.         MessageBox(NULL, _T("Message from '__try' section"), _T("Test"), MB_OK);  
  46.   
  47.         // 除零，人为的使程序崩溃  
  48.         //  
  49.         int i = 13;  
  50.         int j = 0;  
  51.         int m = i / j;  
  52.     }  
  53.     // 捕捉到让程序崩溃的异常时创建Dump文件  
  54.     //  
  55.     __except(CrashHandler(GetExceptionInformation()))  
  56.     {  
  57.         // 这里以弹出一个对话框为例子  
  58.         //  
  59.         MessageBox(NULL, _T("Message from '__except' section"), _T("Test"), MB_OK);  
  60.     }  
  61.   
  62.     MessageBox(NULL, _T("Funcation completed"), _T("Test"), MB_OK);  
  63.   
  64.     return 0;  
  65. }  

        编译上面的代码并运行，会依次弹出下面这些对话框，并在C盘创建一个Dump文件Test.dmp。

让程序在崩溃时体面的退出转第1张让程序在崩溃时体面的退出转第13张让程序在崩溃时体面的退出转第5张让程序在崩溃时体面的退出转第6张

        如果把上面代码中的main()函数改成下面的样子，运行编译后的程序依然会崩溃。

  1. int _tmain(int argc, _TCHAR* argv[])  
  2. {  
  3.     __try  
  4.     {  
  5.         MessageBox(NULL, _T("Message from '__try' section"), _T("Test"), MB_OK);  
  6.   
  7.         // 除零，人为的使程序崩溃  
  8.         //  
  9.         int i = 13;  
  10.         int j = 0;  
  11.         int m = i / j;  
  12.     }  
  13.     // 捕捉到让程序崩溃的异常时创建Dump文件  
  14.     //  
  15.     __except(CrashHandler(GetExceptionInformation()))  
  16.     {  
  17.         // 这里以弹出一个对话框为例子  
  18.         //  
  19.         MessageBox(NULL, _T("Message from '__except' section"), _T("Test"), MB_OK);  
  20.     }  
  21.   
  22.     // 除零，人为的使程序崩溃  
  23.     //  
  24.     int i = 13;  
  25.     int j = 0;  
  26.     int m = i / j;  
  27.   
  28.     MessageBox(NULL, _T("Funcation completed"), _T("Test"), MB_OK);  
  29.   
  30.     return 0;  
  31. }  

        这种情况在实际编程中是很有可能出现的，毕竟我们不可能事先预计到所有可能出现导致程序崩溃的情况，并把这些代码放到try/except块中。那么对于这些不可预知的异常该怎么办呢？这就要用到我那篇《让程序在崩溃时体面的退出之Unhandled Exception》中的方法：用Windows API中的SetUnhandledExceptionFilter设置一个回调函数来处理这些无法预料的异常。下面是在上面的例子代码上修改后的代码。其中函数CreateDumpFile没有任何变化。

  1. // 得到当前时间  
  2. //  
  3. wstring GetPresentTime()  
  4. {  
  5.      SYSTEMTIME time;  
  6.      GetLocalTime(&time);   
  7.   
  8.      wchar_t wszTime[128];  
  9.      swprintf_s(wszTime, _T("%04d-%02d-%02d %02d-%02d-%02d-%03d"), time.wYear, time.wMonth, time.wDay, time.wHour, time.wMinute, time.wSecond, time.wMilliseconds);  
  10.   
  11.      return wstring(wszTime);  
  12. }  
  13.   
  14. // 处理异常的回调函数  
  15. //  
  16. LONG CrashHandler(EXCEPTION_POINTERS *pException)  
  17. {     
  18.     // 在这里添加处理程序崩溃情况的代码  
  19.     //  
  20.   
  21.     // 这里以弹出一个对话框为例子  
  22.     //  
  23.     MessageBox(NULL, _T("Message from Catch handler"), _T("Test"), MB_OK);  
  24.   
  25.     // 以当前时间为文件名  
  26.     //  
  27.     wstring strDumpFileName = _T("C:\\") + GetPresentTime() +_T(".dmp");  
  28.   
  29.     // 创建Dump文件  
  30.     //  
  31.     CreateDumpFile(strDumpFileName.data(), pException);  
  32.   
  33.     return EXCEPTION_EXECUTE_HANDLER;  
  34. }  
  35.   
  36. int _tmain(int argc, _TCHAR* argv[])  
  37. {  
  38.     // 设置处理Unhandled Exception的回调函数  
  39.     //   
  40.     SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)CrashHandler);   
  41.   
  42.     __try  
  43.     {  
  44.         MessageBox(NULL, _T("Message from '__try' section"), _T("Test"), MB_OK);  
  45.   
  46.         // 除零，人为的使程序崩溃  
  47.         //  
  48.         int i = 13;  
  49.         int j = 0;  
  50.         int m = i / j;  
  51.     }  
  52.     __except(CrashHandler(GetExceptionInformation()))  
  53.     {  
  54.         // 在这里添加处理程序崩溃情况的代码  
  55.         //  
  56.   
  57.         // 这里以弹出一个对话框为例子  
  58.         //  
  59.         MessageBox(NULL, _T("Message from '__except' section"), _T("Test"), MB_OK);  
  60.     }  
  61.   
  62.     // 除零，人为的使程序崩溃  
  63.     //  
  64.     int i = 13;  
  65.     int j = 0;  
  66.     int m = i / j;  
  67.   
  68.     MessageBox(NULL, _T("Funcation completed"), _T("Test"), MB_OK);  
  69.   
  70.     return 0;  
  71. }  

        编译上面的代码，运行生成的EXE文件，可以看到在弹出上面提到的那一系列的对话框后，程序正常退出，没有崩溃。同时，在C盘下生成了2个Dump文件，文件名指出了发生异常的时刻。

        上面的代码仅仅是为了说明怎样配合使用SEH和SetUnhandledExceptionFilter，所以except后的表达式和SetUnhandledExceptionFilter中所设置的回调函数都使用了同一个函数CrashHandler。在实际的应用中可以根据不同的需求而使用不同的函数。这个函数的参数必须是一个指向EXCEPTION_POINTERS的指针，返回值必须是这3个中的一个：EXCEPTION_CONTINUE_SEARCH，EXCEPTION_CONTINUE_EXECUTION，EXCEPTION_EXECUTE_HANDLER。这3个值的具体含义可以查阅MSDN或者我的那篇《让程序在崩溃时体面的退出之SEH》。
        实际情况下，是不应该用同一个回调函数的。因为在except表达式中的函数是处理try块中的代码异常的；而用SetUnhandledExceptionFilter设置的回调函数是用来处理代码中没有被捕捉到的异常的。对于未被捕捉到的异常，这个回调函数是不知道异常发生的地方的，虽然可以通过异常代码知道异常的类型，但是由于不知道是什么状况引起的异常，所以没法做出相应的异常处理。一般情况下，这个回调函数是应用程序崩溃前的最后一道防线，这个函数中的代码被执行完后，应用程序就会被终止。所以，大部分的应用程序，在这个函数里都是弹出一个发送错误报告的对话框，来告诉用户程序发生异常，需要终止，可以把错误报告（一般是包括Dump文件和一些必要的文本信息）发送到指定地方帮助开发者来修改代码缺陷，以提高软件质量。

        使用上面的方法编写出的应用程序不会崩溃，并且在出现异常的时候会产生Dump文件。程序的使用者会获得非常良好的用户体验。如果再给应用程序添加上Log信息，配合上Dump文件，就可以很轻松的定位程序中的异常，帮助开发者快速的修复代码中的错误。

标签：#test#编译程序#try#回调函数#messagebox#dump文件 | 浏览：264 | 发布日期：

免责声明：文章转载自《让程序在崩溃时体面的退出转》仅用于学习参考。如对内容有疑问，请及时联系本站处理。

上篇Beyond Compare如何展开所有子文件夹CString之Find（）、FindOneOf()、ReverseFind()下篇

宿迁高防，2C2G15M，22元/月；香港BGP，2C5G5M，25元/月 雨云优惠码：MjYwNzM=

相关文章

Flask-SQLAlchemy数据库ORM

SQLAlchemy 首先需要知道ORM是什么 ORM: Object-Relational Mapping, 对象关系映射, 能够把关系型数据库的表结构映射到模型类对象上, 即实例化一个类对象, 通过操作该对象来操作后台数据库表 使用ORM而不使用手动拼写原生SQL语句有两点好处: 使用起来更加方便, 使用面向对象的一套操作即可操作数据库 能够有效防止...

（转）用Eclipse编译你的ROS程序

原地址： http://blog.csdn.net/sujun3304/article/details/18572017 好了，理解了系统各个组件的含义后，还是直接进入程序真刀真枪的从实践中学习吧！ 不过首先呢，公欲善其事必先利其器，如果你向我一样不是vim和emacs的粉丝，喜欢eclipse的图形界面的话，这篇文章就是为你准备的。 第一步： 首先确保...

php的session

来源：http://blog.163.com/lgh_2002/blog/static/4401752620105246517509/ http协议是WEB服务器与客户 端(浏览器)相互通信的协议，它是一种无状态协议。所谓无状态，指的是不会维护http请求数据，http请求是独立的，非持久的。而越来越复杂的WEB 应用，需要保存一些用户状态信息。这时候，S...

鸢尾花种类预测--数据集

1 案例：鸢尾花种类预测 Iris数据集是常用的分类实验数据集，由Fisher, 1936收集整理。Iris也称鸢尾花卉数据集，是一类多重变量分析的数据集。关于数据集的具体介绍： 2 scikit-learn中数据集介绍 2.1 scikit-learn数据集API介绍 sklearn.datasets 加载获取流行数据集 datasets.load_...

NET 环境中使用RabbitMQ

一 环境搭建 首先，由于RabbitMQ使用Erlang编写的，需要运行在Erlang运行时环境上，所以在安装RabbitMQ Server之前需要安装Erlang 运行时环境，可以到Erlang官网下载对应平台的安装文件。如果没有安装运行时环境，安装RabbitMQ Server的时候，会提示需要先安装Erlang环境。 安装完成之后，确保已经将Erla...

Xcode基本操作

[From] http://blog.csdn.net/phunxm/article/details/17044337 1.Xcode IDE概览 说明：从左到右，依次是“导航窗格（Navigator）->边列（Gutter）->焦点列（Ribbon）->代码编辑窗口（Standard/Primary Editor）”。...

最新文章

随机推荐

思享工具箱导航