windows平台调用函数堆栈的追踪方法 在windows平台，有一个简单的方法来追踪调用函数的堆栈，就是利用函数CaptureStackBackTrace，但是这个函数不能得到具体调用函数的名称，只能得到地址，当然我们可以通过反汇编的方式通过地址得到函数的名称，以及具体调用的反汇编代码，但是对于有的时候我们需要直接得到函数的名称，这个时候据不能使用这个方法，对于这种需求我们可以使用函数：SymInitialize、StackWalk、SymGetSymFromAddr、SymGetLineFromAddr、SymCleanup。原理基本上所有高级语言都有专门为函数准备的堆栈，用来存储函数中定义的变量，在C/C++中在调用函数之前会保存当前函数的相关环境，在调用函数时首先进行参数压栈，然后call指令将当前eip的值压入堆栈中，然后调用函数，函数首先会将自身堆栈的栈底地址保存在ebp中，然后抬高esp并初始化本身的堆栈，通过多次调用最终在堆栈段形成这样的布局这里对函数的原理做简单的介绍，有兴趣的可以看我的另一篇关于C函数原理讲解的博客，点击这里跳转VC++编译器在编译时对函数名称与地址都有详细的记录，编译出来的程序都有一个符号常量表，将符号常量与它对应的地址形成映射，在搜索时首先根据这些堆栈环境找到对应地址，然后根据地址在符号常量表中，找到具体调用的信息，这是一个很复杂的工程，需要对编译原理和汇编有很强的基础，幸运的是，如今这些工作不需要程序员自己去做，windows帮助我们分配了一组API，在编写程序时只需要调用API即可函数说明SymInitialize：这个函数主要用作初始化相关环境。SymCleanup：清楚这个初始化的相关环境，在调用SymInitialize之后需要调用SymCleanup，进行释放资源的操作StackWalk：程序的功能主要由这个函数实现，函数会从初始化时的堆栈顶开始向下查找下一个堆栈的信息，原型如下：BOOL WINAPI StackWalk( __in DWORD MachineType, //机器类型现在一般是intel的x86系列，这个时候填入IMAGE_FILE_MACHINE_I386 __in HANDLE hProcess, //追踪的进程句柄 __in HANDLE hThread, //追踪的线程句柄 __in_out LPSTACKFRAME StackFrame, //记录的追踪到的堆栈信息 __in_out PVOID ContextRecord, //记录当前的线程环境 __in PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine, __in PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine, __in PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine, __in PTRANSLATE_ADDRESS_ROUTINE TranslateAddress //后面的四个参数都是回掉函数，有系统自行调用，而且这些函数都是定义好的，只需要填入相应的函数名称 );需要注意的一点是，在首次调用该函数时需要对StackFrame中的AddrPC、AddrFrame、AddrStack这三个成员进行初始化，填入相关值，以便函数从此处线程堆栈的栈顶进行搜索，否则调用函数将失败，具体如何填写请看MSDN。SymGetSymFromAddr：根据获取到的函数地址得到函数名称、堆栈大小等信息，这个函数的原型如下： BOOL WINAPI SymGetSymFromAddr( __in HANDLE hProcess, //进程句柄 __in DWORD Address, //函数地址 __out PDWORD Displacement, //返回该符号常量的位移或者填入NULL，不获取此值 __out PIMAGEHLP_SYMBOL Symbol//返回堆栈信息 );SymGetLineFromAddr：根据得到的地址值，获取调用函数的相关信息。主要记录是在哪个文件，哪行调用了该函数，下面是函数原型：BOOL WINAPI SymGetLineFromAddr( __in HANDLE hProcess, __in DWORD dwAddr, __out PDWORD pdwDisplacement, __out PIMAGEHLP_LINE Line );它参数的含义与SymGetSymFromAddr，相同。通过上面对函数的说明，我们可以知道，为了追踪函数调用的详细信息，大致步骤如下：首先调用函数SymInitialize进行相关的初始化工作。填充结构体StackFrame的相关信息，确定从何处开始追踪。循环调用StackWalk函数，从指定位置，向下一直追踪到最后。每次将获取的地址分别传入SymGetSymFromAddr、SymGetLineFromAddr，得到函数的详细信息调用SymCleanup，结束追踪但是需要注意的一点是，函数StackWalk会顺着线程堆栈进行查找，如果在调用之前，某个函数已经返回了，它的堆栈被回收，那么函数StackWalk自然不会追踪到该函数的调用。具体实现void InitTrack() { g_hHandle = GetCurrentProcess(); SymInitialize(g_hHandle, NULL, TRUE); } void StackTrack() { g_hThread = GetCurrentThread(); STACKFRAME sf = { 0 }; sf.AddrPC.Offset = g_context.Eip; sf.AddrPC.Mode = AddrModeFlat; sf.AddrFrame.Offset = g_context.Ebp; sf.AddrFrame.Mode = AddrModeFlat; sf.AddrStack.Offset = g_context.Esp; sf.AddrStack.Mode = AddrModeFlat; typedef struct tag_SYMBOL_INFO { IMAGEHLP_SYMBOL symInfo; TCHAR szBuffer[MAX_PATH]; } SYMBOL_INFO, *LPSYMBOL_INFO; DWORD dwDisplament = 0; SYMBOL_INFO stack_info = { 0 }; PIMAGEHLP_SYMBOL pSym = (PIMAGEHLP_SYMBOL)&stack_info; pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL); pSym->MaxNameLength = sizeof(SYMBOL_INFO) - offsetof(SYMBOL_INFO, symInfo.Name); IMAGEHLP_LINE ImageLine = { 0 }; ImageLine.SizeOfStruct = sizeof(IMAGEHLP_LINE); while (StackWalk(IMAGE_FILE_MACHINE_I386, g_hHandle, g_hThread, &sf, &g_context, NULL, SymFunctionTableAccess, SymGetModuleBase, NULL)) { SymGetSymFromAddr(g_hHandle, sf.AddrPC.Offset, &dwDisplament, pSym); SymGetLineFromAddr(g_hHandle, sf.AddrPC.Offset, &dwDisplament, &ImageLine); printf("当前调用函数 : %08x+%s(FILE[%s]LINE[%d])\n", pSym->Address, pSym->Name, ImageLine.FileName, ImageLine.LineNumber); } } void UninitTrack() { SymCleanup(g_hHandle); }测试程序如下：void func1() { OPEN_STACK_TRACK; } void func2() { func1(); } void func3() { func2(); } void func4() { printf("hello\n"); } int _tmain(int argc, TCHAR* argv[]) { func4(); func3(); func3(); return 0; }OPEN_STACK_TRACK是一个宏，它的定义如下：#define OPEN_STACK_TRACK\ HANDLE hThread = GetCurrentThread();\ GetThreadContext(hThread, &g_context);\ __asm{call $ + 5}\ __asm{pop eax}\ __asm{mov g_context.Eip, eax}\ __asm{mov g_context.Ebp, ebp}\ __asm{mov g_context.Esp, esp}\ InitTrack();\ StackTrack();\ UninitTrack();这个程序需要注意以下几点：如果想要追踪所有调用的函数，需要将这个宏放置到最后调用的位置，当然前提是此时之前被调函数的堆栈仍然存在。当然可以在调用前简单的计算，找出在哪个位置是所有函数都没有调用完成的，不过这样可能就与程序的初衷相悖，毕竟程序本身就是为了获取堆栈的调用信息。。。。IMAGEHLP_SYMBOL的结构体中关于Name的成员，只有一个字节，而函数SymGetSymFromAddr在填入值时是没有关心这个实际大小，它只是简单的填充，这就造成了缓冲区溢出的情况，为了避免我们需要在Name后面额外给一定大小的缓冲区，用来接收数据，这也就是我们定义这个结构体SYMBOL_INFO的原因。另外IMAGEHLP_SYMBOL中的MaxNameLength成员是指Name的最大长度，需要根据给定的缓冲区，进行计算。从测试程序来看，在进行追踪时func4已经调用完成，而我们在获取线程的运行时环境g_context时函数GetThreadContext，也在堆栈中，最终得到的结果中必然包含GetThreadContext的调用信息，如果想去掉这个信息，只需要修改获得信息的值，既然函数StackWalk是根据堆栈进行追踪，那么只需要修改对应堆栈的信息即可，需要修改eip 、ebp、esp的值，关于esp ebp的值很好修改，可以在对应函数中esp ebp这些寄存器的值，而eip的值就不那么好获取，本生利用mov指令得到eip的值它也是指令，会改变eip的值，从而造成获取到的eip的值不准确，所以我们利用call指令，先保存当前eip的值到堆栈，然后再从堆栈中取出。call指令的实质是 push eip和jmp addr指令的组合，并不一定非要调用函数。call指令的大小为5个字节，所以call $ + 5表示先保存eip在跳转到它的下一跳指令处。这样就可以有效的避免检测到GetThreadContext中的相关函数调用。

如何将VS 2015中的项目上传到github 最近开始慢慢接触github，现在希望将自己平时写的小程序，上传到github上，以便以后有个参考，在遇到同样问题的时候不至于想不起来怎么做而到处找别人的例子。VS 2015设置首先下载跟github相关的插件在弹出的对话框中选择联机，在右侧的搜索栏中输入关键字，搜索，下载对应的扩展程序重启后点击视图，选择团队资源管理器，选择连接管理在github官网创建代码仓库登陆github的官网，并创建一个代码仓库，记住该代码仓库的地址新建项目选择提交到git上后，在团队资源管理器中会显示这样的界面提交之后回到团队资源管理器的主页中，然后选择同步在地址栏中填入仓库的地址，并点击发布同步成功后，再次到新创建的代码仓库下，刷新一下，会发现这个时候项目已经上传上来了如果程序以后进行更新，那么只需要点击提交，然后填入提交的原因，注意因为上传时需要.opendb 和.db文件，而这个时候VS打开项目时又打开了这两个文件，所以上传会失败，需要在上传时忽略它们.上传它们后只需点击同步即可

windows错误处理 在调用windows API时函数会首先对我们传入的参数进行校验，然后执行，如果出现什么情况导致函数执行出错，有的函数可以通过返回值来判断函数是否出错，比如对于返回句柄的函数如果返回NULL 或者INVALID_HANDLE_VALUE，则函数出错，对于返回指针的函数来说如果返回NULL则函数出错，但是对于有的函数从返回值来看根本不知道是否成功，或者为什么失败，对此windows提供了一大堆的错误码，用于标识API函数是否出错以及出错原因。在windows中为每个线程准备了一个存储区，专门用来存储当前API执行的错误码，想要获取这个错误码可以通过函数GetLastError。在这需要注意的是当前API执行返回的错误码会覆盖之前API返回的错误码，所以在调用API结束后需要立马调用GetLastError来获取该函数返回的错误码。但是windows中的错误码实在太多，有的时候错误码并不直观，windows为每个错误码都关联了一个错误信息的文本，想要通过错误码获取对应的文本信息，可以通过函数FormatMessage来获取。下面是一个具体的例子：#include <windows.h> #include <tchar.h> #include <stdio.h> #include <strsafe.h> #define GRS_OUTPUT(s) WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), s, _tcsclen(s), NULL, NULL) int _tmain(int argc, TCHAR *argv[]) { if (INVALID_HANDLE_VALUE == CreateFile(_T("C:\\Test.txt"), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) { LPTSTR lpMsg = NULL; DWORD dwLastError = GetLastError(); FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError, GetUserDefaultLangID(), (LPTSTR)&lpMsg, 0, NULL); if (NULL != lpMsg) { TCHAR szErrorInfo[1024] = {0}; StringCchPrintf(szErrorInfo, sizeof(szErrorInfo), _T("打开文件失败，失败原因为:%s"), lpMsg); GRS_OUTPUT(szErrorInfo); HeapFree(GetProcessHeap(), 0, lpMsg); } } return 0; }在这段代码中我们没有使用C标准库中的printf，而是使用了windows自带的控制台函数WriteConsole，为了简单，我们定义了一个宏，用来输出字符串。函数WriteConsole的原型如下：BOOL WINAPI WriteConsole( __in HANDLE hConsoleOutput, __in const VOID* lpBuffer, __in DWORD nNumberOfCharsToWrite, __out LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved );函数的第一个参数是控制台的句柄，可以通过函数GetStdHandle来获取，这个函数主要传入一个标志，表示需要获取哪个控制台的句柄，主要有：STD_INPUT_HANDLE（标准输入）、STD_OUTPUT_HANDLE（标准输出）、STD_ERROR_HANDLE（标准错误）第二个参数是字符串的指针，第三个参数是字符个数，第四个参数是实际写入字符个数，由函数返回，如果不关心可以给NULL，最后一个windows作为保留参数通常给NULL。程序首先以打开已存在文件的方式打开一个文件，由于这个文件并不存在，所以函数出错，我们通过GetLastError获取错误码，然后通过FormatMessage来进行转化，该函数原型如下：DWORD FormatMessage( DWORD dwFlags, //标志 LPCVOID lpSource, //根据第一个参数的不同而有不同的解释 DWORD dwMessageId, //错误码 DWORD dwLanguageId, //语言ID LPTSTR lpBuffer, //字符缓冲区，用来存放最终生成的格式字符串 DWORD nSize, //缓冲区大小 va_list* Arguments//作为不定参数类似于printf函数格式化字符串后面的参数 ); 第一个参数是标志，在这我们传入FORMAT_MESSAGE_ALLOCATE_BUFFER，表示字符串缓冲区由该函数为我们分配，而不用自己分配，这个时候为了接受返回的字符缓冲区指针，需要使用二级指针。传入FORMAT_MESSAGE_IGNORE_INSERTS表示忽略插入的信息，也就是说不需要进行sprintf那样的格式化字符串的操作，传入FORMAT_MESSAGE_FROM_SYSTEM表示错误信息的字符串来自于系统定义的。然后进行简单的格式化之后输出错误字符串，最后需要释放内存，虽然FormatMessage函数帮我们分陪了缓冲，但是它不负责释放，需要我们自行释放。另外我们也可以自行进行错误码的设置，利用函数SetLastError可以达到这个效果，以模拟API调用时返回错误码的操作。在windows上一般遵循这样的格式：位31~30292827~1615~0用途严重性系统错误码保留位设备码异常代码含义0 成功 <br/>1供参考<br/>2警告<br/>3错误0系统定义<br/>1自定义总为0系统设备码具体错误码除了获取错误信息之外，还可以获取调用堆栈的快照，可以用函数CaptureStackBackTrace获取，只是这个函数只能获取调用堆栈的线性地址，不能获取到具体的函数名称。下面是它具体的一个例子： const int nCount = 128; PVOID BackTrace[nCount] = {NULL}; int iCnt = CaptureStackBackTrace(0, nCount, BackTrace, NULL); for (int i = 0; i < iCnt; i++) { printf("调用堆栈索引%d, 函数地址:0x%08x\n", i, BackTrace[i]); } return 0;这段代码非常简短，函数只需要四个参数，第一个参数是表示从当前栈顶开始的第几个栈开始便利，第二个参数是共便利多少个栈信息，第三个参数是一个缓冲区，用来存储得到的栈信息，具体就是栈的地址。第四个参数是一个哈希数组，由函数本身返回，如果不需要这个可以设置为NULL。

duilib基本框架 最近我一个同学在项目中使用到了duilib框架，但是之前并没有接触过，他与我讨论这方面的内容，看着官方给出的精美的例子，我对这个库有了很大的兴趣，我自己也是初学这个东东，我在网上花了不少时间来找相关的资料，但是找到的不多，官方给的文档又不全面，但是我还是找到了一些博主贡献的优秀的博文，现在我是通过博文上的讲解加上自己查看源代码的一些心得，正在艰难的前行。现在正在看的是博主Alberl在博客园中的duilib基础教程中的内容，下面的代码都是在他博客中给出代码的基础上做了一点小小的修改。点击这里跳转到对应的博客，以及博主夜雨無聲的博客，博客地址duilib的简介国内首个开源 的directui 界面库,它提供了一个所见即所得的开发工具——UIDesigner，它只有主框架窗口，其余的空间全部采用绘制的方式实现，所以对于控件来说没有句柄和窗口类等内容，它通过UIDesigner工具将用户定义的窗口保存在xml文件中，在创建窗口时读取xml文件中的内容，来绘制相应的控件。目前有许多界面采用duilib编写，大家可以去网上搜集相关资料。环境的配置首先我们去github上获取相关的源代码，这个是对应的项目地址：https://github.com/duilib/duilib下载完后，在目录中找到一个.sln结尾的文件，使用visual studio编译器打开，打开后发现有一个duilib的项目，以及其他，其实真正有用的就是这个duilib，其余的都是官方给出的例子代码。一般只需要编译这个duilib项目就可以了，当初没注意直接点了编译全部的，结果报了一堆错误，其实都是没有对应的lib和dll文件造成的。在VS环境下有一个编译选项，如下图所示上面有4个编译选项，最好将所有的都编译一遍，这样在对应项目的bin目录下会生成四个dll文件，这几个文件分别是debug下的UNICODE编码文件、ANSI文件以及Release版本下的UNICODE编码文件、ANSI文件。u代表unicode d代表debug。另外在lib目录下会生成对应的lib文件。在新建的工程中，点击属性在属性对话框中选择VC++目录，在源文件，库文件，包含文件中将对应的路径添加进去，分别是项目目录和lib文件目录。如下图（刚开始有点问题所以添加的内容有点多，但是不影响正常使用）：最后可以在环境变量的Path变量中添加对应的dll路径，这样就不需要将dll文件拷贝到自己项目的exe文件所在位置处。其实上述的环境可以不用设置，如果不设置，在编写程序包含相关路径时就需要给定完整的路径。到此处为止，整个开发环境就已经搭建好了，剩下的就是代码的编写了。基本的框架窗口首先新建一个Win32类型的项目，添加主函数。然后创建一个新类，我们叫做CDuiFrameWnd，下面是类的源代码//头文件 #include <DuiLib\UIlib.h> using namespace DuiLib; class CDuiFrameWnd : public CWindowWnd { public: CDuiFrameWnd(); ~CDuiFrameWnd(); virtual LPCTSTR GetWindowClassName() const; virtual LRESULT HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam); protected: CPaintManagerUI m_PaintManager; };//cpp文件 LPCTSTR CDuiFrameWnd::GetWindowClassName() const { return _T("DuiFrameWnd"); } LRESULT CDuiFrameWnd::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam) { LRESULT lRes = 0; if (WM_CLOSE == uMsg) { ::CloseWindow(m_hWnd); ::DestroyWindow(m_hWnd); } if (WM_DESTROY == uMsg) { ::PostQuitMessage(0); } return __super::HandleMessage(uMsg, wParam, lParam); }为了能够使用对应的dll文件，还需要引入对应的lib文件，我们在公共的头文件中加入如下代码#ifdef _DEBUG # ifdef _UNICODE # pragma comment(lib, "Duilib_ud.lib") # else # pragma comment(lib, "Duilib_d.lib") # endif #else # ifdef _UNICODE # pragma comment(lib, "Duilib_u.lib") # else # pragma comment(lib, "Duilib.lib") # endif #endif在主函数中的代码如下：int APIENTRY wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPWSTR lpCmdLine, _In_ int nCmdShow) { CPaintManagerUI::SetInstance(hInstance); CDuiFrameWnd duiFrame; //#define UI_WNDSTYLE_FRAME (WS_VISIBLE | WS_OVERLAPPEDWINDOW) duiFrame.Create(NULL, _T("测试"), UI_WNDSTYLE_FRAME, WS_EX_WINDOWEDGE); duiFrame.ShowWindow(); CPaintManagerUI::MessageLoop(); return 0; }这些代码就可以帮助我们生成基本的框架窗口，另外我们需要时刻记住的是duilib是对win32 API的封装，所以可以直接使用win32的编程方式，如果以后有不会用的地方完全可以使用win32 的API来完成相关的功能的编写。框架的剖析既然它能够生成单文档的框架窗口，那么代码中所做的几步基本上与用纯粹的win32 API相同，所以我们沿着这个思路来进行框架的简单剖析。主函数中首先是代码CPaintManagerUI::SetInstance(hInstance);至于类CPaintManagerUI到底有什么作用，这个我也不太清楚，现在我还没有仔细看关于这个类的相关代码，这句话主要还是获取了进程的实例句柄。现在先不关心这个。下面的几步主要是在类CDuiFrameWnd中完成或者说在它的基类CWindowWnd中完成。创建窗口类主函数中的第二段代码主要完成的是类CDuiFrameWnd对象的创建，我们跟到对应的构造函数中发现它并没有做多余的操作，现在先不管它是如何构造的，它下面就是调用了类的Create函数创建了一个窗口，这个函数的代码如下：HWND CWindowWnd::Create(HWND hwndParent, LPCTSTR pstrName, DWORD dwStyle, DWORD dwExStyle, int x, int y, int cx, int cy, HMENU hMenu) { if( GetSuperClassName() != NULL && !RegisterSuperclass() ) return NULL; if( GetSuperClassName() == NULL && !RegisterWindowClass() ) return NULL; m_hWnd = ::CreateWindowEx(dwExStyle, GetWindowClassName(), pstrName, dwStyle, x, y, cx, cy, hwndParent, hMenu, CPaintManagerUI::GetInstance(), this); ASSERT(m_hWnd!=NULL); return m_hWnd; }我们主要来看第二个if中的代码，首先获得了父窗口的字符串为NULL，然后执行RegisterWindowClass，我们进一步跟到RegisterWindowClass中，它的代码如下：bool CWindowWnd::RegisterWindowClass() { WNDCLASS wc = { 0 }; wc.style = GetClassStyle(); wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hIcon = NULL; wc.lpfnWndProc = CWindowWnd::__WndProc; wc.hInstance = CPaintManagerUI::GetInstance(); //之前设置的实例句柄在这个地方使用 wc.hCursor = ::LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = NULL; wc.lpszMenuName = NULL; wc.lpszClassName = GetWindowClassName(); ATOM ret = ::RegisterClass(&wc); ASSERT(ret!=NULL || ::GetLastError()==ERROR_CLASS_ALREADY_EXISTS); return ret != NULL || ::GetLastError() == ERROR_CLASS_ALREADY_EXISTS; }我们发现首先进行的是窗口类的创建，在创建窗口类时主要关心的是窗口类的lpfnWndProc成员和lpszClassName 。lpszClassName 调用了函数GetWindowClassName，这个函数我们在派生类中进行了重写，所以根据多态它会调用派生类的GetWindowClassName函数，将我们给定的字符串作为窗口类的类名注册窗口类从上面的代码可以看出注册的代码也是放在RegisterWindowClass中。在最后调用了RegisterClass函数完成了注册。创建窗口当RegisterWindowClass执行完成后，会接着执行下面的代码，也就是 m_hWnd = ::CreateWindowEx(dwExStyle, GetWindowClassName(), pstrName, dwStyle, x, y, cx, cy, hwndParent, hMenu, CPaintManagerUI::GetInstance(), this);完成创建窗口的任务。显示窗口Create函数执行完成后，会接着执行下面的duiFrame.ShowWindow();我们跟到这个函数中，函数代码如下：void CWindowWnd::ShowWindow(bool bShow /*= true*/, bool bTakeFocus /*= false*/) { ASSERT(::IsWindow(m_hWnd)); if( !::IsWindow(m_hWnd) ) return; ::ShowWindow(m_hWnd, bShow ? (bTakeFocus ? SW_SHOWNORMAL : SW_SHOWNOACTIVATE) : SW_HIDE); }函数ShowWindow默认传入参数为bShow = true bTakeFocus = false；在最后进行ShowWindow函数的调用时，根据bShow和bTakeFocus来进行值得传入，根据代码我们发现，当不传入参数时调用的其实是这样的代码ShowWindow(m_hWnd, SW_SHOWNOACTIVATE);消息循环消息循环其实是通过代码CPaintManagerUI::MessageLoop();完成，我们跟到MessageLoop函数中看 MSG msg = { 0 }; while( ::GetMessage(&msg, NULL, 0, 0) ) { if( !CPaintManagerUI::TranslateMessage(&msg) ) { ::TranslateMessage(&msg); ::DispatchMessage(&msg); } }在这个函数中完成了消息循环。回调函数上面我们留了一个lpfnWndProc函数指针没有说，现在来说明这个部分，跟进到对应的构造函数中，发现类本身不做任何操作，但是父类的构造函数进行了相关的初始化操作，下面是对应的代码CWindowWnd::CWindowWnd() : m_hWnd(NULL), m_OldWndProc(::DefWindowProc), m_bSubclassed(false) { }这样就将lpfnWndProc指向了__WndProc，用于处理默认的消息。这是一个静态的处理函数，下面是它的代码：LRESULT CALLBACK CWindowWnd::__WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CWindowWnd* pThis = NULL; if( uMsg == WM_NCCREATE ) { LPCREATESTRUCT lpcs = reinterpret_cast<LPCREATESTRUCT>(lParam); pThis = static_cast<CWindowWnd*>(lpcs->lpCreateParams); pThis->m_hWnd = hWnd; //当开始创建窗口将窗口类对象的指针放入到对应的GWLP_USERDATA字段中 ::SetWindowLongPtr(hWnd, GWLP_USERDATA, reinterpret_cast<LPARAM>(pThis)); } else { //取出窗口类对象的指针 pThis = reinterpret_cast<CWindowWnd*>(::GetWindowLongPtr(hWnd, GWLP_USERDATA)); if( uMsg == WM_NCDESTROY && pThis != NULL ) { LRESULT lRes = ::CallWindowProc(pThis->m_OldWndProc, hWnd, uMsg, wParam, lParam); ::SetWindowLongPtr(pThis->m_hWnd, GWLP_USERDATA, 0L); if( pThis->m_bSubclassed ) pThis->Unsubclass(); pThis->m_hWnd = NULL; pThis->OnFinalMessage(hWnd); return lRes; } } if( pThis != NULL ) { return pThis->HandleMessage(uMsg, wParam, lParam); } else { return ::DefWindowProc(hWnd, uMsg, wParam, lParam); } }上述的代码，在创建窗口时将窗口类对象指针存入到对应的位置便于在其他位置取出并使用。通过return pThis->HandleMessage(uMsg, wParam, lParam);这句话调用的具体对象的HandleMessage，我们在对应的派生类中定义了相应的虚函数，所以根据多态它会调用我们重写的虚函数来处理具体消息，至于我们不关心的消息，它会调用LRESULT lRes = ::CallWindowProc(pThis->m_OldWndProc, hWnd, uMsg, wParam, lParam);或者DefWindowProc，通过对基类的构造函数的查看，我们发现其实m_OldWndProc就是DefWindowProc。总结上面我们说明了duilib的基本框架，下面来总结一下：CPaintManagerUI::SetInstance(hInstance);设置进程的实例句柄，这个值会在注册窗口类时使用在CWindowWnd类中由Create函数完成窗口类的创建于注册，以及窗口的创建工作CWindowWnd类中的ShowWindow函数用于显示窗口消息循环由CPaintManagerUI::MessageLoop();代码完成最后需要重写MessageHandle函数用于处理我们感兴趣的消息。并且在最后需要调用基类的MessageHandle函数，主要是为了调用DefWindowProc处理我们不感兴趣的消息。

Windows平台下的内存泄漏检测 在C/C++中内存泄漏是一个不可避免的问题，很多新手甚至有许多老手也会犯这样的错误，下面说明一下在windows平台下如何检测内存泄漏。在windows平台下内存泄漏检测的原理大致如下。在分配内存的同时将内存块的信息保存到相应的结构中，标识为已分配当内存释放时在结构中查找，并将相应的标识设置为已释放在需要的位置调用HeapWalk，遍历整个堆内存，找到对应的内存块的首地址，并与定义的结构中的数据相匹配，根据结构中的标识判断是否释放，未释放的话给出相应的提示信息。另外在VS系列的编译器中如果输出的调试信息的格式为：文件名（行号）双击这样的输出信息，会自动跳转到对应的位置，利用这点可以很容易的定位到未释放的内存的位置。为了实现上述功能，我们使用重载new和delete的方式。下面是具体的代码：#define MAX_BUFFER_SIZE 1000 typedef struct tag_ST_BLOCK_INFO { TCHAR m_szSourcePath[MAX_PATH]; INT m_iLine; BOOL m_bDelete; void *pBlock; }ST_BLOCK_INFO, *LP_ST_BLOCK_INFO; class CMemoryLeak { public: CMemoryLeak(void); ~CMemoryLeak(void); void MemoryLeak(); void add(LPCTSTR m_szSourcePath, INT m_iLine, void *pBlock); int GetLength(); ST_BLOCK_INFO& operator [](int nSite); protected: HANDLE m_heap;//自定义堆 LP_ST_BLOCK_INFO m_pBlockInfo; int m_BlockSize; //当前缓冲区大小 int m_hasInfo;//当前记录了多少值 };CMemoryLeak::CMemoryLeak(void) { if (m_heap == NULL) { //打开异常检测 m_heap = HeapCreate(HEAP_GENERATE_EXCEPTIONS,0,0); ULONG HeapFragValue = 2; //允许系统记录堆内存的使用 HeapSetInformation( m_heap,HeapCompatibilityInformation,&HeapFragValue ,sizeof(HeapFragValue)) ; } if (NULL == m_pBlockInfo) { m_pBlockInfo = (LP_ST_BLOCK_INFO)HeapAlloc(m_heap, HEAP_ZERO_MEMORY, MAX_BUFFER_SIZE * sizeof(ST_BLOCK_INFO)); m_BlockSize = MAX_BUFFER_SIZE; m_hasInfo = 0; } } void CMemoryLeak::add(LPCTSTR m_szSourcePath, INT m_iLine, void *pBlock) { //当前缓冲区已满 if (m_hasInfo >= m_BlockSize) { //扩大缓冲区容量 HeapReAlloc(m_heap, HEAP_ZERO_MEMORY, m_pBlockInfo, m_BlockSize * 2 * sizeof(ST_BLOCK_INFO)); m_BlockSize *= 2; } m_pBlockInfo[m_hasInfo].m_bDelete = FALSE; m_pBlockInfo[m_hasInfo].m_iLine = m_iLine; _tcscpy(m_pBlockInfo[m_hasInfo].m_szSourcePath, m_szSourcePath); m_pBlockInfo[m_hasInfo].pBlock = pBlock; m_hasInfo++; } CMemoryLeak::~CMemoryLeak(void) { HeapFree(m_heap, 0, m_pBlockInfo); HeapDestroy(m_heap); } void CMemoryLeak::MemoryLeak() { TCHAR pszOutPutInfo[2*MAX_PATH]; //调试字符串 BOOL bRecord = FALSE; //当前内存是否被记录 PROCESS_HEAP_ENTRY phe = {}; HeapLock(GetProcessHeap()); //检测时锁定堆防止对堆内存进行写入 OutputDebugString(_T("开始检查内存泄露情况.........\n")); while (HeapWalk(GetProcessHeap(), &phe)) { //当这块内存正在使用时 if( PROCESS_HEAP_ENTRY_BUSY & phe.wFlags ) { bRecord = FALSE; for(UINT i = 0; i < m_hasInfo; i ++ ) { if( phe.lpData == m_pBlockInfo[i].pBlock) { //校验这块内存是否被释放 if(!m_pBlockInfo[i].m_bDelete) { StringCchPrintf(pszOutPutInfo,2*MAX_PATH,_T("%s(%d):内存块(Point=0x%08X,Size=%u)\n") ,m_pBlockInfo[i].m_szSourcePath,m_pBlockInfo[i].m_iLine,phe.lpData,phe.cbData); OutputDebugString(pszOutPutInfo); } bRecord = TRUE; break; } } if( !bRecord ) { StringCchPrintf(pszOutPutInfo,2*MAX_PATH,_T("未记录的内存块(Point=0x%08X,Size=%u)\n") ,phe.lpData,phe.cbData); OutputDebugString(pszOutPutInfo); } } } HeapUnlock(GetProcessHeap()); OutputDebugString(_T("内存泄露检查完毕.\n")); } int CMemoryLeak::GetLength() { return m_hasInfo; } ST_BLOCK_INFO& CMemoryLeak::operator [](int nSite) { return m_pBlockInfo[nSite]; } CMemoryLeak g_MemoryLeak; void* __cdecl operator new(size_t nSize,LPCTSTR pszCppFile,int iLine) { //在分配内存的时候将这块内存信息记录到相应的结构中 void *p = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nSize); g_MemoryLeak.add(pszCppFile, iLine, p); return p; } void __cdecl operator delete(void *p, TCHAR *pstrPath, int nLine) { ::operator delete(p); HeapFree(GetProcessHeap(), 0, p); } void __cdecl operator delete(void* p) { //依次遍历结构体数组，找到对应内存块的记录，将标志设置为已删除 for (int i = 0; i < g_MemoryLeak.GetLength(); i++) { if (p == g_MemoryLeak[i].pBlock) { g_MemoryLeak[i].m_bDelete = TRUE; } } HeapFree(GetProcessHeap(), 0, p); }下面是一个测试的例子#ifdef _UNICODE //将__FILE__转化为对应的UNICODE版本 #define GRS_WIDEN2(x) L ## x #define GRS_WIDEN(x) GRS_WIDEN2(x) #define __WFILE__ GRS_WIDEN(__FILE__) //这段代码不能与重载的申明在同一个头文件下，否则在编译时会将定义的new函数进行替换 #define new new(__WFILE__,__LINE__) #define delete(p) ::operator delete(p,__WFILE__,__LINE__) #else #define new new(__FILE__,__LINE__) #define delete(p) ::operator delete(p,__FILE__,__LINE__) #endif int _tmain() { int* pInt1 = new int; int* pInt2 = new int; float* pFloat1 = new float; BYTE* pBt = new BYTE[100]; delete[] pBt; //在DEBUG环境下启用检测 #ifdef _DEBUG g_MemoryLeak.MemoryLeak(); #endif return 0; }上面的代码中，定义了一个结构体 ST_BLOCK_INFO来保存每个分配的内存块的信息，同时采用数组的方式来保存多个内存块的信息，为了便于管理这些信息，专门定义了一个类来操作这个数组，类中记录了数组的首地址，当前保存的信息总量和当前能够容纳的信息总量，同时这个数组支持动态扩展。在遍历时利用HeapWalk函数遍历系统默认堆中的所有内存，找到正在使用的内存，并在结构数组中查找判断内存是否被释放，如果未背释放则输出调试信息。在主函数中利用宏定义的方式，使程序只在debug环境下来校验内存泄漏，方便调试同时在发行时不会拖累程序运行。最后对程序再做最后几点说明：动态数组不要使用new 和delete来分配和释放空间，因为我们重载了这两个函数，这样在检测的时候会有一定的影响new本身的定义如下: void* operator new(size_t size) throw(std::bad_alloc)平时在使用上例如void p = new int 其实等于void p = new(sizeof(int)),同时如果使用void p = new int[10] 等于 void p = new(sizeof(int) 10) 上面定义的#define new new(__WFILE__,__LINE__) 其实在调用时相当于void p = new(__WFILE__,__LINE__) int,也就是等于void *p = new(sizeof(int), __WFILE__,__LINE__)当然delete也是同理在申请数组空间时不要使用系统默认的堆，因为重载new和delete使用的就是系统默认堆，检测的也是默认堆，如果用默认堆来保存数组数据，会对结果产生影响。当然用这样的方式写有点浪费内存资源，如果一个程序需要new出大量的数据，那么需要的额外内存也太多，所以可以使用链表来保存，当调用delete时将结点从链表中删除，这样只要链表中存在的都是未被删除的；或者使用数组，当有一个被删除，将这个位置的索引用队列的方式记录下来，每当要新增数组数据时根据队列中保存的索引找到对应的位置进行覆盖操作。这样可以节省一定的空间。

windows PAE扩展和AWE编程 在32位windows上只能看到最大3GB的内存空间，而且每个应用程序只能访问4GB的的内存，这个限制是windows独有的，为了使程序能够访问大于4GB的内存空间，需要使用AWE编程接口，同时需要开启PAE，让系统支持大于3GB的内存，开启PAE最大能支持128GB的内存。PAE开启在windows 7及以上的系统主要使用BCDEdit命令而XP系统使用的是修改boot.ini文件的方式，下面主要介绍的是windows 7 上开启PAE的方式在命令行下输入BCDEdit /set PAE forceenable windows另外如果需要扩大用户分区可以打开/3GB开关，这个开关在windows 7上用命令：BCDEdit /set IncreaseUseVa 3072(后面的数字代表的是用户分区的大小，3072正是3GB)另外编译选项需要打开/LARGEADDRESSAWARE开关AWE编程接口开启PAE之后想要自己的程序能够访问到超过4GB的内存，需要使用AWE的编程接口，AWE(Address Windowing Extensions)是地址窗口扩展。使用AWE时,所有物理页面的交换控制就由应用程序自己控制使用的基本步骤:使用VirtualAlloc + MEM_PHYSICAL分配保留一段地址空间准备用于存储页表的数组申请分配物理内存(AllocateUserPhysicalPages)将物理内存映射到“窗口”中(MapUserPhysicalPages)对映射的内存进行读写操作释放物理内存页面(FreeUserPhysicalPages)释放对应的保留地址空间下面是使用AWE的简单例子#define MEMORY_REQUESTED 1024 * 1024 * 1024 //1GB BOOL bResult; // generic Boolean value ULONG_PTR NumberOfPages; // number of pages to request ULONG_PTR NumberOfPagesInitial; // initial number of pages requested ULONG_PTR *aPFNs1; // page info; holds opaque data ULONG_PTR *aPFNs2; // page info; holds opaque data PVOID lpMemReserved; // AWE window SYSTEM_INFO sSysInfo; // useful system information int PFNArraySize; // memory to request for PFN array TCHAR* pszData; TCHAR pszReadData[100]; MEMORYSTATUSEX ms = {sizeof(MEMORYSTATUSEX)}; GlobalMemoryStatusEx(&ms); //使用VirtualAlloc + MEM_PHYSICAL分配保留一段地址空间 lpMemReserved = VirtualAlloc( NULL,MEMORY_REQUESTED, MEM_RESERVE | MEM_PHYSICAL, PAGE_READWRITE ); //计算需要的物理页面大小 以及物理页面需要的页表数组大小 GetSystemInfo(&sSysInfo); // fill the system information structure //向上取整，计算出需要多少个页表项 NumberOfPages = (MEMORY_REQUESTED + sSysInfo.dwPageSize - 1)/sSysInfo.dwPageSize; PFNArraySize = NumberOfPages * sizeof (ULONG_PTR); //2 准备物理页面的页表数组数据 aPFNs1 = (ULONG_PTR *) HeapAlloc(GetProcessHeap(), 0, PFNArraySize); aPFNs2 = (ULONG_PTR *) HeapAlloc(GetProcessHeap(), 0, PFNArraySize); NumberOfPagesInitial = NumberOfPages; //3 分配物理页面 bResult = AllocateUserPhysicalPages( GetCurrentProcess(),&NumberOfPages,aPFNs1 ); bResult = AllocateUserPhysicalPages( GetCurrentProcess(),&NumberOfPages,aPFNs2 ); //4 映射第一个1GB到保留的空间中 bResult = MapUserPhysicalPages( lpMemReserved,NumberOfPages,aPFNs1 ); pszData = (TCHAR*)lpMemReserved; _tcscpy(pszData,_T("这是第一块物理内存")); //5 映射第二个1GB到保留的空间中 bResult = MapUserPhysicalPages( lpMemReserved,NumberOfPages,aPFNs2 ); _tcscpy(pszData,_T("这是第二块物理内存")); //6 再映射回第一块内存,并读取开始部分 bResult = MapUserPhysicalPages( lpMemReserved,NumberOfPages,aPFNs1 ); _tcscpy(pszReadData,pszData); //7 取消映射 bResult = MapUserPhysicalPages( lpMemReserved,NumberOfPages,NULL ); //8 释放物理页面 bResult = FreeUserPhysicalPages( GetCurrentProcess(),&NumberOfPages,aPFNs1 ); bResult = FreeUserPhysicalPages( GetCurrentProcess(),&NumberOfPages,aPFNs2 ); //9 释放保留的"窗口"空间 bResult = VirtualFree( lpMemReserved,0, MEM_RELEASE ); //10 释放页表数组 bResult = HeapFree(GetProcessHeap(), 0, aPFNs1); bResult = HeapFree(GetProcessHeap(), 0, aPFNs2); _tsystem(_T("PAUSE"));上述代码中，虽然只保留了1GB的虚拟地址空间，但是这1GB的虚拟地址空间通过映射的方式，映射到具体不同的真实内存中，这个就是PAE能访问大于4GB内存的秘密，通过对分页机制的了解，4字节的虚拟地址空间能够映射4KB的一页内存，所以经过简单的计算，其实没多映射1GB的内存其实只需要1M的数组来存储这些页表项。64位的windows不再也没有必要支持AWE技术，因为这个技术就是为了解决应用程序访问内存不足的情况，但是在64位系统中不存在这个问题，也许有朝一日64位的操作系统也会出现能够访问的内存太少的情况，这个时候说不定会出现类似于AWE的技术

windows 堆管理 windows堆管理是建立在虚拟内存管理的基础之上的，每个进程都有独立的4GB的虚拟地址空间，其中有2GB的属于用户区，保存的是用户程序的数据和代码，而系统在装载程序时会将这部分内存划分为4个段从低地址到高地址依次为静态存储区，代码段，堆段和栈段，其中堆的生长方向是从低地址到高地址，而栈的生长方向是从高地址到低地址。程序申请堆内存时，系统会在虚拟内存的基础上分配一段内存，然后记录下来这块的大小和首地址，并且在对应内存块的首尾位置各有相应的数据结构，所以在堆内存上如果发生缓冲区溢出的话，会造成程序崩溃，这部分没有硬件支持，所有管理算法都有开发者自己设计实现。堆内存管理的函数主要有HeapCreate、HeapAlloc、HeapFree、HeapRealloc、HeapDestroy、HeapWalk、HeapLock、HeapUnLock。下面主要通过一些具体的操作来说明这些函数的用法。堆内存的分配与释放堆内存的分配主要用到函数HeapAlloc，下面是这个函数的原型：LPVOID HeapAlloc( HANDLE hHeap, //堆句柄，表示在哪个堆上分配内存 DWORD dwFlags, //分配的内存的相关标志 DWORD dwBytes //大小 );堆句柄可以使用进程默认堆也可以使用用户自定义的堆，自定义堆使用函数HeapCreate，函数返回堆的句柄，使用GetProcessHeap可以获取系统默认堆，返回的也是一个堆句柄。分配内存的相关标志有这样几个值：HEAP_NO_SERIALIZE：这个表示对堆内存不进行线程并发控制，由于系统默认会进行堆的并发控制，防止多个线程同时分配到了同一个堆内存，如果程序是单线程程序则可以添加这个选项，适当提高程序运行效率。HEAP_ZERO_MEMORY：这个标志表示在分配内存的时候同时将这块内存清零。HeapCreate函数的原型如下：HANDLE HeapCreate( DWORD flOptions, //堆的相关属性 DWORD dwInitialSize, //堆初始大小 DWORD dwMaximumSize //堆所占内存的最大值 );flOptions的取值如下：HEAP_NO_SERIALIZE：取消并发控制HEAP_SHARED_READONLY：其他进程可以以只读属性访问这个堆dwInitialSize， dwMaximumSize这两个值如果都是0，那么堆内存的初始大小由系统分配，并且堆没有上限，会根据具体的需求而增长。下面是使用的例子： //在系统默认堆中分配内存 srand((unsigned int)time(NULL)); HANDLE hHeap = GetProcessHeap(); int nCount = 1000; float *pfArray = (float *)HeapAlloc(hHeap, HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE, nCount * sizeof(float)); for (int i = 0; i < nCount; i++) { pfArray[i] = 1.0f * rand(); } HeapFree(hHeap, HEAP_NO_SERIALIZE, pfArray); //在自定义堆中分配内存 hHeap = HeapCreate(HEAP_GENERATE_EXCEPTIONS, 0, 0); pfArray = (float *)HeapAlloc(hHeap, HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE, nCount * sizeof(float)); for (int i = 0; i < nCount; i++) { pfArray[i] = 1.0f * rand(); } HeapFree(hHeap, HEAP_NO_SERIALIZE, pfArray); HeapDestroy(hHeap);遍历进程中所有堆的信息：便利堆的信息主要用到函数HeapWalk，该函数的原型如下：BOOL WINAPI HeapWalk( __in HANDLE hHeap,//堆的句柄 __in_out LPPROCESS_HEAP_ENTRY lpEntry//返回堆内存的相关信息 );下面是PROCESS_HEAP_ENTRY的原型：typedef struct _PROCESS_HEAP_ENTRY { PVOID lpData; DWORD cbData; BYTE cbOverhead; BYTE iRegionIndex; WORD wFlags; union { struct { HANDLE hMem; DWORD dwReserved[3]; } Block; struct { DWORD dwCommittedSize; DWORD dwUnCommittedSize; LPVOID lpFirstBlock; LPVOID lpLastBlock; } Region; }; } PROCESS_HEAP_ENTRY, *LPPROCESS_HEAP_ENTRY;这个结构中的公用体具体使用哪个与wFlags相关，下面是这些值得具体含义：wFlags堆入口含义lpDatacbDatacbOverhead块前堆数据结构大小iRegionIndexBlockRegionPROCESS_HEAP_ENTRY_BUSY被分配的内存块首地址内存块大小内存块前堆数据结构所在区域索引无意义无意义PROCESS_HEAP_ENTRY_DDESHAREDDE共享内存块首地址内存块大小内存块前堆数据结构所在区域索引无意义无意义PROCESS_HEAP_ENTRY_MOVEABLE可移动的内存块(兼容GlobalAllocLocalAlloc）首地址（可移动内存句柄的首地址）内存块大小内存块前堆数据结构所在区域索引与PROCESS_HEAP_ENTRY_BUSY标志一同指定可移动内存句柄值无意义PROCESS_HEAP_REGION已提交的堆虚拟内存区域区域开始地址区域大小区域前堆数据结构区域索引无意义虚拟内存区域详细信息PROCESS_HEAP_UNCOMMITTED_RANGE未提交的堆虚拟内存区域区域开始地址区域大小区域前堆数据结构区域索引无意义无意义下面是时遍历堆内存的例子： PHANDLE pHeaps = NULL; //当传入的参数为0和NULL时，函数返回进程中堆的个数 int nCount = GetProcessHeaps(0, NULL); pHeaps = new HANDLE[nCount]; //获取进程所有堆句柄 GetProcessHeaps(nCount, pHeaps); PROCESS_HEAP_ENTRY phe = {0}; for (int i = 0; i < nCount; i++) { cout << "Heap handle: 0x" << pHeaps[i] << '\n'; //在读取堆中的相关信息时需要将堆内存锁定，防止程序向堆中写入数据 HeapLock(pHeaps[i]); HeapWalk(pHeaps[i], &phe); //输出堆信息 cout << "\tSize: " << phe.cbData << " - Overhead: " << static_cast<DWORD>(phe.cbOverhead) << '\n'; cout << "\tBlock is a"; if(phe.wFlags & PROCESS_HEAP_REGION) { cout << " VMem region:\n"; cout << "\tCommitted size: " << phe.Region.dwCommittedSize << '\n'; cout << "\tUncomitted size: " << phe.Region.dwUnCommittedSize << '\n'; cout << "\tFirst block: 0x" << phe.Region.lpFirstBlock << '\n'; cout << "\tLast block: 0x" << phe.Region.lpLastBlock << '\n'; } else { if(phe.wFlags & PROCESS_HEAP_UNCOMMITTED_RANGE) { cout << "n uncommitted range\n"; } else if(phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) { cout << "n Allocated range: Region index - " << static_cast<unsigned>(phe.iRegionIndex) << '\n'; if(phe.wFlags & PROCESS_HEAP_ENTRY_MOVEABLE) { cout << "\tMovable: Handle is 0x" << phe.Block.hMem << '\n'; } else if(phe.wFlags & PROCESS_HEAP_ENTRY_DDESHARE) { cout << "\tDDE Sharable\n"; } } else cout << " block, no other flags specified\n"; } cout << std::endl; HeapUnlock(pHeaps[i]); ZeroMemory(&phe, sizeof(PROCESS_HEAP_ENTRY)); } delete[] pHeaps;另外堆还有其他操作，比如使用HeapSize获取分配的内存大小，使用HeapValidate可以校验一个对内存的完整性,从而提早发现”野指针”等等。

windows虚拟内存管理 内存管理是操作系统非常重要的部分，处理器每一次的升级都会给内存管理方式带来巨大的变化，向早期的8086cpu的分段式管理，到后来的80x86 系列的32位cpu推出的保护模式和段页式管理。在应用程序中我们无时不刻不在和内存打交道，我们总在不经意间的进行堆内存和栈内存的分配释放，所以内存是我们进行程序设计必不可少的部分。CPU的内存管理方式段寄存器怎么消失了？在学习8086汇编语言时经常与寄存器打交道，其中8086CPU采用的内存管理方式为分段管理的方式，寻址时采用：短地址 * 16 + 偏移地址的方式，其中有几大段寄存器比如：CS、DS、SS、ES等等，每个段的偏移地址最大为64K，这样总共能寻址到2M的内存。但是到32位CPU之后偏移地址变成了32位这样每个段就可以有4GB的内存空间，这个空间已经足够大了，这个时候在编写相应的汇编程序时我们发现没有段寄存器的身影了，是不是在32位中已经没有段寄存器了呢，答案是否定了，32位CPU中不仅有段寄存器而且它们的作用比以前更大了。在32位CPU中段寄存器不再作为段首地址，而是作为段选择子，CPU为了管理内存，将某些连续的地址内存作为一页，利用一个数据结构来说明这页的属性，比如是否可读写，大小，起始地址等等，这个数据结构叫做段描述符，而多个段描述符则组成了一个段描述符表，而段寄存器如今是用来找到对应的段描述符的，叫做段选择子。段寄存器仍然是16位其中高13位表示段描述符表的索引，第二位是区分LDT(局部描述符表)和GDT（全局描述符表），全局描述符表是系统级的而LDT是每个进程所独有的，如果第二位表示的是LDT，那么首先要从GDT中查询到LDT所在位置，然后才根据索引找到对应的内存地址，所以现在寻址采用的是通过段选择子查表的方式得到一个32位的内存地址。由于这些表都是由系统维护，并且不允许用户访问及修改所以在普通应用程序中没有必要也不能使用段寄存器。通过上面的说明，我们可以推导出来32位机器最多可以支持2^(13 + 1 + 32) = 64T内存。段页式管理通过查表方式得到的32位内存地址是否就是真实的物理内存的地址呢，这个也是不一定的，这个还要看系统是否开启了段页式管理。如果没有则这个就是真实的物理地址，如果开启了段页式管理那么这个只是一个线性地址，还需要通过页表来寻址到真实的物理内存。32位CPU专门新赠了一个CR3寄存器用来完成分页式管理，通过CR3寄存器可以寻址到页目录表，然后再将32位线性地址的高10位作为页目录表的索引，通过这个索引可以找到相应的页表，再将中间10为作为页表的索引，通过这个索引可以寻址到对应物理内存的起始地址，最后通过这个其实地址和最后低12位的偏移地址找到对应真实内存。下面是这个过程的一个示例图：为什么要使用分页式管理，直接让那个32位线性地址对应真实的内存不可以吗。当然可以，但是分页式管理也有它自身的优点：可以实现页面的保护：系统通过设置相关属性信息来指定特权级别和其他状态可以实现物理内存的共享：从上面的图中可以看出，不同的线性地址是可以映射到相同的物理内存上的，只需要更改页表中对应的物理地址就可以实现不同的线性地址对应相同的物理内存实现内存共享。可以方便的实现虚拟内存的支持：在系统中有一个pagefile.sys的交互页面文件，这个是系统用来进行内存页面与磁盘进行交互，以应对内存不够的情况。系统为每个内存页维护了一个值，这个值表示该页面多久未被访问，当页面被访问这个值被清零，否则每过一段时间会累加一次。当这个值到达某个阈值时，系统将页面中的内容放入磁盘中，将这块内存空余出来以便保存其他数据，同时将之前的线性地址做一个标记，表名这个线性地址没有对应到具体的内存中，当程序需要再次访问这个线性地址所对应的内存时系统会再次将磁盘中的数据写入到内存中。虽说这样做相当于扩大了物理内存，但是磁盘相对于内存来说是一个慢速设备，在内存和磁盘间进行数据交换总是会耗费大量的时间，这样会拖慢程序运行，而采用SSD硬盘会显著提高系统运行效率，就在于SSD提高了与内存进行数据交换的效率。如果想显著提高效率，最好的办法是加内存毕竟在内存和硬盘间倒换数据是要话费时间的。保护模式在以前的16位CPU中采用的多是实模式，程序中使用的地址都是真实的物理地址，这样如果内存分配不合理，会造成一个程序将另外一个程序所在的内存覆盖这样对另外一个程序将造成严重影响，但是在32位保护模式下，不再会产生这种问题，保护模式将每个进程的地址空间隔离开来，还记得上面的LDT吗，在不同的程序中即使采用的是相同的地址，也会被LDT映射到不同的线性地址上。保护模式主要体现在这样几个方面：1.同一进程中，使用4个不同访问级别的内存段，对每个页面的访问属性做了相应的规定，防止错误访问的情况，同时为提供了4中不同代码特权，0特权的代码可以访问任意级别的内存，1特权能任意访问1...3级内存,但不能访问0级内存,依次类推。通常这些特权级别叫做ring0-ring3。对于不同的进程，将他们所用到的内存等资源隔离开来，一个进程的执行不会影响到另一个进程。windows系统的内存管理windows内存管理器我们将系统中实际映射到具体的实际内存上的页面称为工作集。当进程想访问多余实际物理内存的内存时，系统会启用虚拟内存管理机制（工作集管理），将那些长时间未访问的物理页面复制到硬盘缓冲文件上，并释放这些物理页面，映射到虚拟空间的其它页面上；系统的内存管理器主要由下面的几个部分组成：工作集管理器(优先级16)：这个主要负责记录每个页面的年龄，也就有多久未被访问，当页面被访问这个年龄被清零，否则每过一段时间就进行累加1的操作。进程/栈交换器(优先级23)：主要用于在进行进程或者线程切换时保存寄存器中的相关数据用以保存相关环境。已修改页面写出器(优先级17)：当内存映射的内容发生改变时将这个改变及时的写入到硬盘中，防止由于程序意外终止而造成数据丢失映射页面写出器(优先级17)：当页面的年龄达到一定的阈值时，将页面内容写入到硬盘中解引用段线程(优先级18)：释放以写入到硬盘中的空闲页面零页面线程(优先级0)：将空闲页面清零，以便程序下次使用，这个线程保证了新提交的页面都是干净的零页面进程虚拟地址空间的布局windows为每个进程提供了平坦的4GB的线性地址空间，这个地址空间被分为用户分区和内核分区，他们各占2GB大小，其中内核分区在高地址位，用户分区在低地址位，下面是内存分布的一个表格：分区地址范围NULL指针区0x00000000-0x0000FFFF用户分区0x00010000-0x7FFEFFFF64K禁入区0x7FFF0000-0x7FFFFFFF内核分区0x80000000-0xFFFFFFFF从上面的图中可以看出，系统的内核分区是2GB而用户可用的分区并没有2GB，在用户分区的头64K和尾部的64K不允许用户使用。另外我们可以压缩内核分区的大小，以便使用户分区占更多的内存，这就是/3GB方式，下面是这种方式的具体内存分布：分区地址范围NULL指针区0x00000000-0x0000FFFF用户分区0x00010000-0xBFFEFFFF64K禁入区0xBFFF0000-0xBFFFFFFF内核分区0xC0000000-0xFFFFFFFFwindows虚拟内存管理函数VirtualAllocVirtualAlloc函数主要用于提交或者保留一段虚拟地址空间，通过该函数提交的页面是经过0页面线程清理的干净的页面。LPVOID VirtualAlloc( LPVOID lpAddress, //虚拟内存的地址 DWORD dwSize, //虚拟内存大小 DWORD flAllocationType,//要对这块的虚拟内存做何种操作 DWORD flProtect //虚拟内存的保护属性 ); 我们可以指定第一个参数来告知系统，我们希望操作哪块内存，如果这个地址对应的内存已经被保留了那么将向下偏移至64K的整数倍，如果这块内存已经被提交，那么地址将向下偏移至4K的整数倍，也就是说保留页面的最小粒度是64K，而提交的最小粒度是一页4K。第三个参数是指定分配的类型，主要有以下几个值值含义MEM_COMMIT提交，也就是说将虚拟地址映射到对应的真实物理内存中，这样这块内存就可以正常使用MEM_RESERVE保留，告知系统以这个地址开始到后面的dwSize大小的连续的虚拟内存程序要使用，进程其他分配内存的操作不得使用这段内存。MEM_TOP_DOWN从高端地址保留空间(默认是从低端向高端搜索)MEM_LARGE_PAGES开启大页面的支持，默认一个页面是4K而大页面是2M（这个视具体系统而定）MEM_WRITE_WATCH开启页面写入监视,利用GetWriteWatch可以得到写入页面的统计情况,利用ResetWriteWatch可以重置起始计数MEM_PHYSICAL用于开启PAE第四个参数主要是页面的保护属性，参数可取值如下：值含义PAGE_READONLY只读PAGE_READWRITE可读写PAGE_EXECUTE可执行PAGE_EXECUTE_READ可读可执行PAGE_EXECUTE_READWRITE可读可写可执行PAGE_NOACCESS不可访问PAGE_GUARD将该页设置为保护页，如果试图对该页面进行读写操作，会产生一个STATUS_GUARD_PAGE 异常下面是该函数使用的几个例子：页面的提交/保留与释放//保留并提交 LPVOID pMem = VirtualAlloc(NULL, 4 * 4096, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); srand((unsigned int)time(NULL)); float* pfMem = (float*)pMem; for (int i = 0; i < 4 * 4096 / sizeof(float); i++) { pfMem[i] = rand(); } //释放 VirtualFree(pMem, 4 * 4096, MEM_RELEASE); //先保留再提交 LPBYTE pByte = (LPBYTE)VirtualAlloc(NULL, 1024 * 1024, MEM_RESERVE, PAGE_READWRITE); VirtualAlloc(pByte + 4 * 4096, 4096, MEM_COMMIT, PAGE_READWRITE); pfMem = (float*)(pByte + 4 * 4096); for (int i = 0; i < 4096/sizeof(float); i++) { pfMem[i] = rand(); } //释放 VirtualFree(pByte + 4 * 4096, 4096, MEM_DECOMMIT); VirtualFree(pByte, 1024 * 1024, MEM_RELEASE);大页面支持//获得大页面的尺寸 DWORD dwLargePageSize = GetLargePageMinimum(); LPVOID pBuffer = VirtualAlloc(NULL, 64 * dwLargePageSize, MEM_RESERVE, PAGE_READWRITE); //提交大页面 VirtualAlloc(pBuffer, 4 * dwLargePageSize, MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE); VirtualFree(pBuffer, 4 * dwLargePageSize, MEM_DECOMMIT); VirtualFree(pBuffer, 64 * dwLargePageSize, MEM_RELEASE);VirtualProtectVirtualProtect用来设置页面的保护属性，函数原型如下：BOOL VirtualProtect( LPVOID lpAddress, //虚拟内存地址 DWORD dwSize, //大小 DWORD flNewProtect, //保护属性 PDWORD lpflOldProtect //返回原来的保护属性 ); 这个保护属性与之前介绍的VirtualAlloc中的保护属性相同，另外需要注意的一点是一般返回原来的属性的话，这个指针可以为NULL，但是这个函数不同，如果第四个参数为NULL，那么函数调用将会失败LPVOID pBuffer = VirtualAlloc(NULL, 4 * 4096, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); float *pfArray = (float*)pBuffer; for (int i = 0; i < 4 * 4096 / sizeof(float); i++) { pfArray[i] = 1.0f * rand(); } //将页面改为只读属性 DWORD dwOldProtect = 0; VirtualProtect(pBuffer, 4 * 4096, PAGE_READONLY, &dwOldProtect); //写入数据将发生异常 pfArray[9] = 0.1f; VirtualFree(pBuffer, 4 * 4096, MEM_RELEASE);VirtualQuery这个函数用来查询某段虚拟内存的属性信息，这个函数原型如下：DWORD VirtualQuery( LPCVOID lpAddress,//地址 PMEMORY_BASIC_INFORMATION lpBuffer, //用于接收返回信息的指针 DWORD dwLength //缓冲区大小，上述结构的大小 ); 结构MEMORY_BASIC_INFORMATION的定义如下：typedef struct _MEMORY_BASIC_INFORMATION { PVOID BaseAddress; //该页面的起始地址 PVOID AllocationBase;//分配给该页面的首地址 DWORD AllocationProtect;//页面的保护属性 DWORD RegionSize; //页面大小 DWORD State;//页面状态 DWORD Protect;//页面的保护类型 DWORD Type;//页面类型 } MEMORY_BASIC_INFORMATION; typedef MEMORY_BASIC_INFORMATION *PMEMORY_BASIC_INFORMATION; AllocationProtect与Protect所能取的值与之前的保护属性的值相同。State的取值如下：MEM_FREE：空闲MEM_RESERVE：保留MEM_COMMIT：已提交Type的取值如下：MEM_IMAGE：映射类型，一般是映射到地址控件的可执行模块如DLL，EXE等MEM_MAPPED：文件映射类型MEM_PRIVATE：私有类型，这个页面的数据为本进程私有数据，不能与其他进程共享下面是这个的使用例子：#include<windows.h> #include <stdio.h> #include <tchar.h> #include <atlstr.h> CString GetMemoryInfo(MEMORY_BASIC_INFORMATION *pmi); int _tmain(int argc, TCHAR *argv[]) { SYSTEM_INFO sm = {0}; GetSystemInfo(&sm); LPVOID dwMinAddress = sm.lpMinimumApplicationAddress; LPVOID dwMaxAddress = sm.lpMaximumApplicationAddress; MEMORY_BASIC_INFORMATION mbi = {0}; _putts(_T("BaseAddress\tAllocationBase\tAllocationProtect\tRegionSize\tState\tProtect\tType\n")); for (LPVOID pAddress = dwMinAddress; pAddress <= dwMaxAddress;) { if (VirtualQuery(pAddress, &mbi, sizeof(MEMORY_BASIC_INFORMATION)) == 0) { break; } _putts(GetMemoryInfo(&mbi)); //一般通过BaseAddress（页面基地址） + RegionSize（页面长度）来寻址到下一个页面的的位置 pAddress = (BYTE*)mbi.BaseAddress + mbi.RegionSize; } } CString GetMemoryInfo(MEMORY_BASIC_INFORMATION *pmi) { CString lpMemoryInfo = _T(""); int iBaseAddress = (int)(pmi->BaseAddress); int iAllocationBase = (int)(pmi->AllocationBase); CString szProtected = _T("\0"); if (pmi->Protect & PAGE_READONLY) { szProtected = _T("R"); }else if (pmi->Protect & PAGE_READWRITE) { szProtected = _T("RW"); }else if (pmi->Protect & PAGE_WRITECOPY) { szProtected = _T("WC"); }else if (pmi->Protect & PAGE_EXECUTE) { szProtected = _T("X"); }else if (pmi->Protect & PAGE_EXECUTE_READ) { szProtected = _T("RX"); }else if (pmi->Protect & PAGE_EXECUTE_READWRITE) { szProtected = _T("RWX"); }else if (pmi->Protect & PAGE_EXECUTE_WRITECOPY) { szProtected = _T("WCX"); }else if (pmi->Protect & PAGE_GUARD) { szProtected = _T("GUARD"); }else if (pmi->Protect & PAGE_NOACCESS) { szProtected = _T("NOACCESS"); }else if (pmi->Protect & PAGE_NOCACHE) { szProtected = _T("NOCACHE"); }else { szProtected = _T(" "); } CString szAllocationProtect = _T("\0"); if (pmi->AllocationProtect & PAGE_READONLY) { szProtected = _T("R"); }else if (pmi->AllocationProtect & PAGE_READWRITE) { szProtected = _T("RW"); }else if (pmi->AllocationProtect & PAGE_WRITECOPY) { szProtected = _T("WC"); }else if (pmi->AllocationProtect & PAGE_EXECUTE) { szProtected = _T("X"); }else if (pmi->AllocationProtect & PAGE_EXECUTE_READ) { szProtected = _T("RX"); }else if (pmi->AllocationProtect & PAGE_EXECUTE_READWRITE) { szProtected = _T("RWX"); }else if (pmi->AllocationProtect & PAGE_EXECUTE_WRITECOPY) { szProtected = _T("WCX"); }else if (pmi->AllocationProtect & PAGE_GUARD) { szProtected = _T("GUARD"); }else if (pmi->AllocationProtect & PAGE_NOACCESS) { szProtected = _T("NOACCESS"); }else if (pmi->AllocationProtect & PAGE_NOCACHE) { szProtected = _T("NOCACHE"); }else { szProtected = _T(" "); } DWORD dwRegionSize = pmi->RegionSize; CString strState = _T(""); if (pmi->State & MEM_FREE) { strState = _T("Free"); }else if (pmi->State & MEM_RESERVE) { strState = _T("Reserve"); }else if (pmi->State & MEM_COMMIT) { strState = _T("Commit"); }else { strState = _T(" "); } CString strType = _T(""); if (pmi->Type & MEM_IMAGE) { strType = _T("Image"); }else if (pmi->Type & MEM_MAPPED) { strType = _T("Mapped"); }else if (pmi->Type & MEM_PRIVATE) { strType = _T("Private"); } lpMemoryInfo.Format(_T("%08X %08X %s %d %s %s %s\n"), iBaseAddress, iAllocationBase, szAllocationProtect, dwRegionSize, strState, szProtected, strType); return lpMemoryInfo; }VirtualLock和VirtualUnlock这两个函数用于锁定和解锁页面，前面说过操作系统会将长时间不用的内存中的数据放入到系统的磁盘文件中，需要的时候再放回到内存中，这样来回倒腾，必定会造成程序效率的底下，为了避免这中效率底下的操作，可以使用VirtualLock将页面锁定在内存中，防止页面交换，但是不用了的时候需要使用VirtualUnlock来解锁，不然一直锁定而不解锁会造成真实内存的不足。另外需要注意的是，不能一次操作超过工作集规定的最大虚拟内存，这样会造成程序崩溃，我们可以通过函数SetProcessWorkingSetSize来设置工作集规定的最大虚拟内存的大小。下面是一个使用例子：SetProcessWorkingSetSize(GetCurrentProcess(), 1024 * 1024, 2 * 1024 * 1024); LPVOID pBuffer = VirtualAlloc(NULL, 4 * 4096, MEM_RESERVE, PAGE_READWRITE); //不能锁定超过进程工作集大小的虚拟内存 VirtualLock(pBuffer, 3 * 1024 * 1024); //不能一次提交超过进程工作集大小的虚拟内存 VirtualAlloc(pBuffer, 3 * 1024 * 1024, MEM_COMMIT, PAGE_READWRITE); float *pfArray = (float*)pBuffer; for (int i = 0; i < 4096 / sizeof(float); i++) { pfArray[i] = 1.0f * rand(); } VirtualUnlock(pBuffer, 4096); VirtualFree(pBuffer, 4096, MEM_DECOMMIT); VirtualFree(pBuffer, 4 * 4096, MEM_RELEASE);VirtualFreeVirtualFree用于释放申请的虚拟内存。这个函数支持反提交和释放，这两个操作由第三个参数指定：MEM_DECOMMIT：反提交，这样这个线性地址就不再映射到具体的物理内存，但是这个地址仍然是保留地址。MEM_RELEASE：释放，这个范围的地址不再作为保留地址

windows服务管理操作 服务程序是windows上重要的一类程序，它们虽然不与用户进行界面交互，但是它们对于系统有着重要的意义。windows上为了管理服务程序提供了一个特别的程序：服务控制管理程序，系统上关于服务控制管理的API基本上都与这个程序打交道。下面通过对服务程序的操作来说明这些API函数获取系统服务的信息在windows系统中有专门用来存储服务信息的数据库，而获取系统服务信息主要是通过在这样的数据库中查找。所用到的函数主要有：OpenSCManager：打开数据库SC_HANDLE WINAPI OpenSCManager( __in LPCTSTR lpMachineName, __in LPCTSTR lpDatabaseName, __in DWORD dwDesiredAccess ); 这个函数主要用来连接特定计算机上的服务控制管理器，并打开服务控制管理器的数据库。函数的参数有：lpMachineName:主机名称lpDatabaseName:主机中服务数据库的名称dwDesiredAccess:以何种权限打开服务程序前两个参数都可以为NULL，如果第一个参数为NULL，则表示在本机上获取，第二个参数为NULL表示从注册表中获取，第三个参数的主要传入如下值：SC_MANAGER_ALL_ACCESS (0xF003F) ：默认拥有所有权限SC_MANAGER_CREATE_SERVICE (0x0002)：具有创建服务的权限SC_MANAGER_CONNECT (0x0001)：连接的权利 SC_MANAGER_ENUMERATE_SERVICE (0x0004) 枚举里面信息的权限后面的就不再一一说明了，详细信息请看MSDN的记录。在程序中为了方便一般采用SC_MANAGER_ALL_ACCESS 参数函数如果调用成功，则会返回一个操作数据库的句柄，以后的关于服务的操作都已这个参数作为第一个参数。EnumServicesStatus：枚举系统服务BOOL WINAPI EnumServicesStatus( __in SC_HANDLE hSCManager, __in DWORD dwServiceType, __in DWORD dwServiceState, __out LPENUM_SERVICE_STATUS lpServices, __in DWORD cbBufSize, __out LPDWORD pcbBytesNeeded, __out LPDWORD lpServicesReturned, __in_out LPDWORD lpResumeHandle );hSCManager：服务数据库句柄dwServiceType：枚举服务的类型，主要有：SERVICE_DRIVER（驱动类型服务）、SERVICE_WIN32（win32类型的服务）dwServiceState：表示枚举哪中状态的服务，主要有：SERVICE_ACTIVE（已启动的服务）、SERVICE_INACTIVE（未启动的服务）、SERVICE_STATE_ALL（所有服务）lpServices：这个参数主要是作为一个缓冲区，用来返回服务信息，类型ENUM_SERVICE_STATUS主要存储的是服务名称、显示名称以及一个SERVICE_STATUS 结构体，该结构体的原型如下：typedef struct _SERVICE_STATUS{ DWORD dwServiceType; //服务类型 DWORD dwControlsAccepted;//当前状态 DWORD dwServiceSpecificExitCode; DWORD dwCheckPoint; DWORD dwWaitHint; } SERVICE_STATUS, *LPSERVICE_STATUS;cbBufSize：缓冲区的大小pcbBytesNeeded：实际需要缓冲区的大小lpServicesReturned：服务的返回值lpResumeHandle：额外的句柄每一个ENUM_SERVICE_STATUS结构体保存的是一个服务的信息，但是我们事先并不知道有多少个服务，因此不知道该定义多大的服务信息数组，但是windows考虑到了这一点，当函数调用失败时利用GetLastError返回ERROR_MORE_DATA时表示提供的缓冲区不够，这个时候参数pcbBytesNeeded会返回正确的大小，所以使用这个函数一般会经过两个调用第一次lpServices = NULL, cbBufSize = 0,这个时候函数出错并返回所需要的实际大小，然后根据大小动态分陪一个内存缓冲区或者提供一个数组，并传入实际大小，以获取所有服务的信息。下面提供一个具体的例子： SC_HANDLE scHandle = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); if(NULL == scHandle) { return FALSE; } LPENUM_SERVICE_STATUS pServices = NULL; DWORD dwByteNeed = 0; DWORD dwServiceReturn = 0; LPDWORD lpResumeHandle = NULL; //第一次调用，将缓冲区设置为NULL并将缓冲区大小设置为0 BOOL bRet = ::EnumServicesStatus(scHandle, SERVICE_WIN32, SERVICE_STATE_ALL, pServices, 0, &dwByteNeed, &dwServiceReturn, lpResumeHandle); if(!bRet) { //如果是因为缓冲区大小不够 if(ERROR_MORE_DATA == GetLastError()) { //保存缓冲区的真实大小 DWORD dwRealNeed = dwByteNeed; //多分配一个是为了保存字符串末尾的0 pServices = (LPENUM_SERVICE_STATUS)new char[dwRealNeed + 1]; ASSERT(NULL != pServices); ZeroMemory(pServices, dwRealNeed + 1); bRet = ::EnumServicesStatus(scHandle, SERVICE_WIN32, SERVICE_STATE_ALL, pServices, dwRealNeed + 1, &dwByteNeed, &dwServiceReturn, lpResumeHandle); //通过上述代码可以获取到服务的相关信息 } }获取服务的主程序所在路径、启动类型以及依赖项上述代码只能获取到系统服务的部分信息，比如服务的名称，显示名称，等等至于其他的信息需要调用另外的API函数获取OpenService获取具体服务的句柄SC_HANDLE WINAPI OpenService( __in SC_HANDLE hSCManager, //服务数据库的句柄 __in LPCTSTR lpServiceName,//服务的名称 __in DWORD dwDesiredAccess//以何种权限打开，为了方便一般填入SERVICE_ALL_ACCESS所有权限 );QueryServiceConfig 查询系统服务信息BOOL WINAPI QueryServiceConfig( __in SC_HANDLE hService, __out LPQUERY_SERVICE_CONFIG lpServiceConfig, __in DWORD cbBufSize, __out LPDWORD pcbBytesNeeded );这个函数的第二个参数是一个结构体指针这个结构体的定义如下：typedef struct _QUERY_SERVICE_CONFIG { DWORD dwServiceType; //服务类型 DWORD dwStartType; //启动类型 DWORD dwErrorControl;//错误码，服务执行出错时返回，操作系统根据这个错误码来做相应的处理 LPTSTR lpBinaryPathName;//主程序所在路径 LPTSTR lpLoadOrderGroup; DWORD dwTagId; LPTSTR lpDependencies; //依赖项 LPTSTR lpServiceStartName; LPTSTR lpDisplayName; //显示名称 } QUERY_SERVICE_CONFIG, *LPQUERY_SERVICE_CONFIG;这个函数的调用方式与EnumServicesStatus相同，也是通过两次调用，第一次获得所需的空间大小，这个大小通过第四个参数返回。下面的代码展示了如何调用这两个函数//第一个参数是通过OpenSCManager函数获取得到的 SC_HANDLE h_SCService = OpenService(h_SCHandle, pSrvItem->strSrvName, SERVICE_ALL_ACCESS); if(NULL == h_SCService) { CloseServiceHandle(h_SCHandle); return FALSE; } LPQUERY_SERVICE_CONFIG pSrvConfig = NULL; DWORD dwBuffSize = 0; DWORD dwBuffNeed = 0; BOOL bRet = QueryServiceConfig(h_SCService, pSrvConfig, dwBuffSize, &dwBuffNeed); if(!bRet) { if(ERROR_INSUFFICIENT_BUFFER == GetLastError()) { DWORD dwRealNeed = dwBuffNeed; pSrvConfig = (LPQUERY_SERVICE_CONFIG)new char[dwRealNeed + 1]; ASSERT(NULL != pSrvConfig); bRet = QueryServiceConfig(h_SCService, pSrvConfig, dwRealNeed, &dwBuffNeed); } }获取服务的描述信息描述信息一般是有服务开发人员提供，以便解释服务程序的作用等等信息，这些信息在注入服务时由系统记录，并呈现给用户。获取系统服务主要使用的API函数是QueryServiceConfig2BOOL WINAPI QueryServiceConfig2( __in SC_HANDLE hService, __in DWORD dwInfoLevel,//将获取何种信息在这我们需要填写SERVICE_CONFIG_DESCRIPTION表示获取描述信息 __out LPBYTE lpBuffer, __in DWORD cbBufSize, __out LPDWORD pcbBytesNeeded );这个函数不想上面的QueryServiceConfig一次可以获取服务的多项信息，它是根据第二个参数指定需要获取哪项信息，然后返回到第3个参数提供的缓冲区中，这个缓冲区是一个BYTE类型的指针，调用者需要根据具体的情况进行类型转化。同样这个函数需要进行两次调用。BOOL bRet = QueryServiceConfig2(h_SCService, SERVICE_CONFIG_DESCRIPTION, (LPBYTE)lpByte, cbBufSize, &dwBuffNeed); if(!bRet) { if(ERROR_INSUFFICIENT_BUFFER == GetLastError()) { DWORD dwRealNeed = dwBuffNeed; //LPSERVICE_DESCRIPTION结构体中只保存了一个字符串指针lpDescription lpByte = (LPSERVICE_DESCRIPTION)new char[dwRealNeed + 1]; ASSERT(NULL != lpByte); bRet = QueryServiceConfig2(h_SCService, SERVICE_CONFIG_DESCRIPTION, (LPBYTE)lpByte, dwRealNeed, &dwBuffNeed); if(!bRet) { delete[] lpByte; goto __ERROR_RET; } pSrvItem->strSrvDescrible = lpByte->lpDescription; delete[] lpByte; CloseServiceHandle(h_SCService); CloseServiceHandle(h_SCHandle); return TRUE; } } __ERROR_RET: CloseServiceHandle(h_SCService); CloseServiceHandle(h_SCHandle); return FALSE;服务的控制服务控制主要控制服务的启动，暂停，恢复，停止等等。StartService启动服务BOOL WINAPI StartService( __in SC_HANDLE hService, __in DWORD dwNumServiceArgs,//启动参数的个数 __in LPCTSTR* lpServiceArgVectors//参数列表指针 );这个函数有点类似于main函数，main函数可以传递命令行参数给程序，以便实现程序与用户的交互，这里同样可以传递参数，以便服务完成特定的功能，当第二个参数为0时第三个参数为NULLControlService 控制服务BOOL WINAPI ControlService( __in SC_HANDLE hService, __in DWORD dwControl,//新状态 __out LPSERVICE_STATUS lpServiceStatus//服务的原始状态 );这个函数用来完成除了启动之外的服务控制，其中第二个参数是服务的状态，它可使用的参数主要有如下几个：取值含义SERVICE_CONTROL_CONTINUE继续运行SERVICE_CONTROL_PAUSE暂停SERVICE_CONTROL_STOP停止其余的部分不是很常用，故不在这里一一列举下面是一个具体的例子，由于要考虑当前的状态以及服务是否支持这种状态，因此这部分的代码多了许多判断的部分SERVICE_STATUS ServiceStatus = {0}; //获取当前的状态 BOOL bRet = QueryServiceStatus(h_SCService, &ServiceStatus); ASSERT(bRet); if(ServiceStatus.dwCurrentState == dwNewStatus) { goto __RETURN; } //如果当前服务正处在启动和暂停之中，但是没有完成这个动作时不允许改变服务状态 if(ServiceStatus.dwCurrentState == SERVICE_CONTINUE_PENDING || SERVICE_PAUSE_PENDING ==ServiceStatus.dwCurrentState || SERVICE_START_PENDING == ServiceStatus.dwCurrentState || SERVICE_STOP_PENDING == ServiceStatus.dwCurrentState) { bRet = FALSE; goto __RETURN; } //如果服务处在暂停状态，则只允许继续运行和停止 if(SERVICE_PAUSED == ServiceStatus.dwCurrentState) { if(SERVICE_CONTROL_CONTINUE == dwNewStatus || SERVICE_CONTROL_STOP == dwNewStatus) { bRet = ControlService(h_SCService, dwNewStatus, &ServiceStatus); goto __RETURN; }else { bRet = FALSE; goto __RETURN; } } //如果服务正在运行，则运行暂停和停止 if(SERVICE_RUNNING == ServiceStatus.dwCurrentState) { if(SERVICE_CONTROL_PAUSE == dwNewStatus || SERVICE_CONTROL_STOP == dwNewStatus) { bRet = ControlService(h_SCService, dwNewStatus, &ServiceStatus); goto __RETURN; }else { bRet = FALSE; goto __RETURN; } } //如果服务处于停止状态，则允许运行操作 if(SERVICE_STOPPED == ServiceStatus.dwCurrentState) { if(SERVICE_RUNNING == dwNewStatus) { bRet = StartService(h_SCService, 0, NULL); goto __RETURN; }else { bRet = FALSE; goto __RETURN; } } __RETURN: if(bRet) { pIter->pNode->dwCurrentStatus = dwNewStatus; } CloseServiceHandle(h_SCService); CloseServiceHandle(h_SCHandle); return bRet;当前服务的状态可以使用EnumServicesStatus函数获取，但是这个函数是获取系统中记录的所有的服务程序，在这样的情况下，我们只需要获取一个服务的状态，调用这个函数总有杀鸡用牛刀的意思，所以采用的是另外一个函数QueryServiceStatus，服务程序的主要状态有如下几种：取值状态描述SERVICE_RUNNING已启动SERVICE_STOPPED已停止SERVICE_PAUSED已暂停SERVICE_CONTINUE_PENDING正在恢复SERVICE_PAUSE_PENDING正在暂停SERVICE_START_PENDING正在启动SERVICE_STOP_PENDING正在停止其中前几个是完成时，也就是完成了从一个状态到另一个的转化，而后面几个是进行时，正在这两种状态之间获取服务的可控类型在控制服务时不光要考虑服务程序当前的状态，还要考虑它是否支持这种状态，比如有的服务就不支持暂停和恢复操作QueryServiceStatus 查询服务的状态信息这个函数主要传递一个SERVICE_STATUS结构体的指针。这个结构体的定义如下：typedef struct _SERVICE_STATUS { DWORD dwServiceType;//服务类型 DWORD dwCurrentState; //当前状态 DWORD dwControlsAccepted;//允许的操作 DWORD dwWin32ExitCode; DWORD dwServiceSpecificExitCode; DWORD dwCheckPoint; DWORD dwWaitHint; } SERVICE_STATUS, *LPSERVICE_STATUS;改变服务的启动类型服务的启动类型主要有开机启动、手动启动、以及禁止启动等项。改变启动类型的函数主要是：ChangeServiceConfig。函数原型如下：BOOL WINAPI ChangeServiceConfig( __in SC_HANDLE hService, __in DWORD dwServiceType,//服务类型 __in DWORD dwStartType,//启动类型 __in DWORD dwErrorControl, __in LPCTSTR lpBinaryPathName,//服务的主程序路径 __in LPCTSTR lpLoadOrderGroup, __out LPDWORD lpdwTagId, __in LPCTSTR lpDependencies,//依赖项 __in LPCTSTR lpServiceStartName,//服务名称 __in LPCTSTR lpPassword,//服务密码，主要用于控制服务 __in LPCTSTR lpDisplayName//服务的显示名称 );函数中传递的都是服务的新信息，如果希望改变则填入相应的值，如果不想改变则对于DWORD类型的成员来说填入SERVICE_NO_CHANGE，对于指针类型的只需要填入NULL即可。创建服务创建服务主要使用函数CreateService，该函数的原型如下：SC_HANDLE WINAPI CreateService( __in SC_HANDLE hSCManager, __in LPCTSTR lpServiceName,//服务名称 __in LPCTSTR lpDisplayName,//显示名称 __in DWORD dwDesiredAccess,//服务权限 __in DWORD dwServiceType,//服务类型 __in DWORD dwStartType,//服务启动类型 __in DWORD dwErrorControl, __in LPCTSTR lpBinaryPathName,//主程序路径 __in LPCTSTR lpLoadOrderGroup, __out LPDWORD lpdwTagId, __in LPCTSTR lpDependencies,//依赖项 __in LPCTSTR lpServiceStartName,启动名称 __in LPCTSTR lpPassword//密码 ); 在启动时需要填入一些信息系统的服务控制管理器保存这些信息，并根据其中的某些信息来启动这个服务，有的选项是必填的，比如服务名称，这个是用来唯一标识一个服务的，服务所在路径告知服务控制管理器启动哪个程序，而向依赖、密码等等信息可以不用填写。 下面是调用的例子SC_HANDLE hRet = ::CreateService(h_SCManager, lpServiceName, lpDisplayName, dwDesiredAccess, SERVICE_WIN32_OWN_PROCESS, dwStartType, SERVICE_ERROR_NORMAL, lpBinaryPathName, NULL, NULL, lpDependencies, lpServiceStartName, lpPassword);SERVICE_WIN32_OWN_PROCESS表示服务类型是win32类型拥有独立进程的服务 SERVICE_ERROR_NORMAL表示服务程序返回的错误码是系统默认的错误码 ## 删除服务 删除服务使用的函数是DeleteService，这个函数主要传入的是服务的句柄，这个句柄是由函数OpenService返回的。另外需要注意的是这个函数只对已停止的服务起作用，所以在删除之前需要将服务停止。BOOL bRet = FALSE;DWORD dwSrvAcceptCtrl = GetSrvCtrlAccept(pIter->pNode->strSrvName); if(0 == (dwSrvAcceptCtrl & SERVICE_ACCEPT_STOP)) //服务不能被删除 { goto __RETURN; } //停止服务，函数CtrlService是我之前封装的用于控制服务。 bRet = CtrlService(pIter, SERVICE_CONTROL_STOP); if(!bRet) { goto __RETURN; } bRet = ::DeleteService(h_SCService); if (bRet) { DeleteItem(pIter->pNode); }__RETURN:CloseServiceHandle(h_SCService); CloseServiceHandle(h_SCManager); return bRet;

C++继承分析 面向对象的三大特性之一就是继承，继承运行我么重用基类中已经存在的内容，这样就简化了代码的编写工作。继承中有三种继承方式即:public protected private，这三种方式规定了不同的访问权限，这些权限的检查由编译器在语法检查阶段进行，不参与生成最终的机器码，所以在这里不对这三中权限进行讨论，一下的内容都是采用的共有继承。单继承首先看下面的代码：class CParent { public: CParent(){ printf("CParent()\n"); } ~CParent(){ printf("~CParent()\n"); } void setNumber(int n){ m_nParent = n; } int getNumber(){ return m_nParent; } protected: int m_nParent; }; class CChild : public CParent { public: void ShowNumber(int n){ setNumber(n); m_nChild = 2 *m_nParent; printf("child:%d\n", m_nChild); printf("parent:%d\n", m_nParent); } protected: int m_nChild; }; int main() { CChild cc; cc.ShowNumber(2); return 0; }上面的代码中定义了一个基类，以及一个对应的派生类，在派生类的函数中，调用和成员m_nParent，我们没有在派生类中定义这个变量，很明显这个变量来自于基类，子类会继承基类中的函数成员和数据成员，下面的汇编代码展示了它是如何存储以及如何调用函数的:41: CChild cc; 004012AD lea ecx,[ebp-14h];将类对象的首地址this放入ecx中 004012B0 call @ILT+5(CChild::CChild) (0040100a);调用构造函数 004012B5 mov dword ptr [ebp-4],0 42: cc.ShowNumber(2); 004012BC push 2 004012BE lea ecx,[ebp-14h] 004012C1 call @ILT+10(CChild::ShowNumber) (0040100f);调用自身的函数 43: return 0; 004012C6 mov dword ptr [ebp-18h],0 004012CD mov dword ptr [ebp-4],0FFFFFFFFh 004012D4 lea ecx,[ebp-14h] 004012D7 call @ILT+25(CChild::~CChild) (0040101e);调用析构函数 004012DC mov eax,dword ptr [ebp-18h] ;构造函数 0040140A mov dword ptr [ebp-4],ecx 0040140D mov ecx,dword ptr [ebp-4];到此ecx和ebp - 4位置的值都是对象的首地址 00401410 call @ILT+35(CParent::CParent) (00401028);调用父类的构造 00401415 mov eax,dword ptr [ebp-4] ;ShowNumber函数 00401339 pop ecx;还原this指针 0040133A mov dword ptr [ebp-4],ecx;ebp - 4存储的是this指针 31: setNumber(n); 0040133D mov eax,dword ptr [ebp+8];ebp + 8是showNumber参数 00401340 push eax 00401341 mov ecx,dword ptr [ebp-4] 00401344 call @ILT+0(CParent::setNumber) (00401005) 32: m_nChild = 2 *m_nParent; 00401349 mov ecx,dword ptr [ebp-4] 0040134C mov edx,dword ptr [ecx];取this对象的头4个字节的值到edx中 0040134E shl edx,1;edx左移1位，相当于edx = edx * 2 00401350 mov eax,dword ptr [ebp-4] 00401353 mov dword ptr [eax+4],edx ;将edx的值放入到对象的第4个字节处 33: printf("child:%d\n", m_nChild); 00401356 mov ecx,dword ptr [ebp-4] 00401359 mov edx,dword ptr [ecx+4] 0040135C push edx 0040135D push offset string "child:%d\n" (0042f02c) 00401362 call printf (00401c70) 00401367 add esp,8 34: printf("parent:%d\n", m_nParent); 0040136A mov eax,dword ptr [ebp-4] 0040136D mov ecx,dword ptr [eax] 0040136F push ecx 00401370 push offset string "parent:%d\n" (0042f01c) 00401375 call printf (00401c70) 0040137A add esp,8 ;setNumber函数 16: m_nParent = n; 004013CD mov eax,dword ptr [ebp-4] 004013D0 mov ecx,dword ptr [ebp+8] 004013D3 mov dword ptr [eax],ecx;给对象的头四个字节赋值从上面的汇编代码可以看到大致的执行流程，首先调用编译器提供的默认构造函数，在这个构造函数中调用父类的构造函数，然后在showNumber中调用setNumber为父类的m_nParent赋值，然后为m_nChild赋值，最后执行输出语句。上面的汇编代码在执行为m_nParent赋值时操作的内存地址是this，而为m_nChild赋值时操作的是this + 4通过这一点可以看出，类CChild在内存中的分布，首先在低地址位分步的是基类的成员，高地址为分步的是派生类的成员，我们随着代码的执行，查看寄存器和内存的值也发现，m_nParent在低地址位m_nChild在高地址位：当父类中含有构造函数，而子类中没有时，编译器会提供默认构造函数，这个构造只调用父类的构造，而不做其他多余的操作，但是如果子类中构造，而父类中没有构造，则不会为父类提供默认构造。但是当父类中有虚函数时又例外，这个时候会为父类提供默认构造，以便初始化虚函数表指针。在析构时，为了可以析构父类会首先调用子类的析构，当析构到父类的部分时，调用父类的构造，也就是说析构的调用顺序与构造正好相反。子类在内存中的排列顺序为先依次摆放父类的成员，后安排子类的成员。C++中的函数符号名称与C中的有很大的不同，编译器根据这个符号名称可以知道这个函数的形参列表，和作用范围，所以在继承的情况下，父类的成员函数的作用范围在父类中，而派生类则包含了父类的成员，所以自然包含了父类的作用范围，在进行函数调用时，会首先在其自身的范围中查找，然后再在其父类中查找，因此子类可以调用父类的函数。在子类中将父类的成员放到内存的前段是为了方便子类调用父类中的成员。但是当子类中有对应的函数，这个时候会直接调用子类中的函数，这个时候发生了覆盖。当类中定义了其他类成员，并定义了初始化列表时，构造的顺序又是怎样的呢？class CParent { public: CParent(){ m_nParent = 0; } protected: int m_nParent; }; class CInit { public: CInit(){ m_nNumber = 0; } protected: int m_nNumber; }; class CChild : public CParent { public: CChild(): m_nChild(1){} protected: CInit m_Init; int m_nChild; };34: CChild cc; 00401288 lea ecx,[ebp-0Ch] 0040128B call @ILT+5(CChild::CChild) (0040100a) ;构造函数 004012C9 pop ecx 004012CA mov dword ptr [ebp-4],ecx 004012CD mov ecx,dword ptr [ebp-4] 004012D0 call @ILT+25(CParent::CParent) (0040101e);先调用父类的构造 004012D5 mov ecx,dword ptr [ebp-4] 004012D8 add ecx,4 004012DB call @ILT+0(CInit::CInit) (00401005);然后调用类成员的构造 004012E0 mov eax,dword ptr [ebp-4] 004012E3 mov dword ptr [eax+8],1;最后调用初始化列表中的操作 004012EA mov eax,dword ptr [ebp-4]综上分析，编译器在对对象进行初始化时是根据各个部分在内存中的排放顺序来进行初始化的，就上面的例子来说，最上面的是基类的所以它首先调用的是基类的构造，然后是类的成员，所以接着调用成员对象的构造函数，最后是自身定义的变量，所以最后初始化自身的变量，但是初始化列表中的操作是先于类自身构造函数中的代码的。由于父类的成员在内存中的分步是先于派生类自身的成员，所以通过派生类的指针可以很容易寻址到父类的成员，而且可以将派生类的指针转化为父类进行操作，并且不会出错，但是反过来将父类的指针转化为派生类来使用则会造成越界访问。下面我们来看一下对于虚表指针的初始化问题，如果在基类中存在虚函数，而且在派生类中重写这个虚函数的话，编译器会如何初始化虚表指针。class CParent { public: virtual void print(){ printf("CParent()\n"); } }; class CChild : public CParent { public: virtual void print(){ printf("CChild()\n"); } }; int main() { CChild cc; return 0; } ;函数地址 @ILT+0(?print@CParent@@UAEXXZ): 00401005 jmp CParent::print @ILT+10(?print@CChild@@UAEXXZ): 0040100F jmp CChild::print ;派生类构造函数 004012C9 pop ecx 004012CA mov dword ptr [ebp-4],ecx 004012CD mov ecx,dword ptr [ebp-4] 004012D0 call @ILT+30(CParent::CParent) (00401023) 004012D5 mov eax,dword ptr [ebp-4] 004012D8 mov dword ptr [eax],offset CChild::`vftable' (0042f01c) 004012DE mov eax,dword ptr [ebp-4] ;基类构造函数 00401379 pop ecx 0040137A mov dword ptr [ebp-4],ecx 0040137D mov eax,dword ptr [ebp-4] 00401380 mov dword ptr [eax],offset CParent::`vftable' (0042f02c)上述代码的基本流程是首先执行基类的构造函数，在基类中首先初始化虚函数指针，从上面的汇编代码中可以看到，这个虚函数指针的值为0x0042f02c查看这块内存可以看到，它保存的值为0x00401005上面我们列出的虚函数地址可以看到，这个值正是基类中虚函数的地址。当基类的构造函数调用完成后，接着执行派生类的虚表指针的初始化，将它自身虚函数的地址存入到虚表中。通过上面的分析可以知道，在派生类中如果重写了基类中的虚函数，那么在创建新的类对象时会有两次虚表指针的初始化操作，第一次是将基类的虚表指针赋值给对象，然后再将自身的虚表指针赋值给对象，将前一次的覆盖，如果是在基类的构造中调用虚函数，这个时候由于还没有生成派生类，所以会直接寻址，找到基类中的虚函数，这个时候不会构成多态，但是如果在派生类的构造函数中调用，这个时候已经初始化了虚表指针，会进行虚表的间接寻址调用派生类的虚函数构成多态。析构函数与构造函数相反，在执行析构时，会首先将虚表指针赋值为当前类的虚表地址，调用当前类的虚函数，然后再将虚表指针赋值为其基类的虚表地址，执行基类的虚函数。多重继承多重继承的情况与单继承的情况类似，只是其父类变为多个，首先来分析多重继承的内存分布情况class CParent1 { public: virtual void fnc1(){ printf("CParent1 fnc1\n"); } protected: int m_n1; }; class CParent2 { public: virtual void fnc2(){ printf("CParent2 fnc2\n"); } protected: int m_n2; }; class CChild : public CParent1, public CParent2 { public: virtual void fnc1(){ printf("CChild fnc1()\n"); } virtual void fnc2(){ printf("CChild fnc2()\n"); } protected: int m_n3; }; int main() { CChild cc; CParent1 *p = &cc; p->fnc1(); CParent2 *p1 = &cc; p1->fnc2(); p = NULL; p1 = NULL; return 0; }上述代码中，CChild类有两个基类，CParent1 CParent2 ，并且重写了这两个类中的函数：fnc1 fnc2，然后在主函数中分别将cc对象转化为它的两个基类的指针，通过指针调用虚函数，实现多态。下面是它的反汇编代码43: CChild cc; 004012A8 lea ecx,[ebp-14h];对象的this指针 004012AB call @ILT+15(CChild::CChild) (00401014) 44: CParent1 *p = &cc; 004012B0 lea eax,[ebp-14h] 004012B3 mov dword ptr [ebp-18h],eax;[ebp - 18h]是p的值 45: p->fnc1(); 004012B6 mov ecx,dword ptr [ebp-18h] 004012B9 mov edx,dword ptr [ecx];对象的头四个字节是虚函数表指针 004012BB mov esi,esp 004012BD mov ecx,dword ptr [ebp-18h] 004012C0 call dword ptr [edx];通过虚函数地址调用虚函数 ;部分代码略 46: CParent2 *p1 = &cc; 004012C9 lea eax,[ebp-14h];eax = this 004012CC test eax,eax 004012CE je main+48h (004012d8);校验this是否为空 004012D0 lea ecx,[ebp-0Ch];this指针向下偏移8个字节 004012D3 mov dword ptr [ebp-20h],ecx 004012D6 jmp main+4Fh (004012df) 004012D8 mov dword ptr [ebp-20h],0;如果this为null会将edx赋值为0 004012DF mov edx,dword ptr [ebp-20h];edx = this + 8 004012E2 mov dword ptr [ebp-1Ch],edx;[ebp - 1CH]是p1的值 47: p1->fnc2(); 004012E5 mov eax,dword ptr [ebp-1Ch] 004012E8 mov edx,dword ptr [eax] 004012EA mov esi,esp 004012EC mov ecx,dword ptr [ebp-1Ch] 004012EF call dword ptr [edx] 004012F1 cmp esi,esp 004012F3 call __chkesp (00401680) ;CChild构造函数 0040135A mov dword ptr [ebp-4],ecx 0040135D mov ecx,dword ptr [ebp-4] 00401360 call @ILT+40(CParent1::CParent1) (0040102d) 00401365 mov ecx,dword ptr [ebp-4] 00401368 add ecx,8;将指向对象首地址的指针向下偏移了8个字节 0040136B call @ILT+45(CParent2::CParent2) (00401032) 00401370 mov eax,dword ptr [ebp-4] 00401373 mov dword ptr [eax],offset CChild::`vftable' (0042f020) 00401379 mov ecx,dword ptr [ebp-4] 0040137C mov dword ptr [ecx+8],offset CChild::`vftable' (0042f01c) 00401383 mov eax,dword ptr [ebp-4] ;CParent1构造函数 00401469 pop ecx 0040146A mov dword ptr [ebp-4],ecx 0040146D mov eax,dword ptr [ebp-4] 00401470 mov dword ptr [eax],offset CParent1::`vftable' (0042f04c);初始化虚表指针 00401476 mov eax,dword ptr [ebp-4] ;CParent2构造函数 004014F9 pop ecx 004014FA mov dword ptr [ebp-4],ecx 004014FD mov eax,dword ptr [ebp-4] 00401500 mov dword ptr [eax],offset CParent2::`vftable' (0042f064);初始化虚表指针 00401506 mov eax,dword ptr [ebp-4] ;虚函数地址 @ILT+0(?fnc2@CChild@@UAEXXZ): 00401005 jmp CChild::fnc2 (00401400) @ILT+5(?fnc1@CParent1@@UAEXXZ): 0040100A jmp CParent1::fnc1 (00401490) @ILT+10(?fnc1@CChild@@UAEXXZ): 0040100F jmp CChild::fnc1 (004013b0) @ILT+20(?fnc2@CParent2@@UAEXXZ): 00401019 jmp CParent2::fnc2 (00401520)内存地址存储的值0012FF6C20 F0 42 000012FF70CC CC CC CC0012FF741C F0 42 000012FF78CC CC CC CC0012FF7CCC CC CC CC从上面的汇编代码中可以看到，在为该类对象分配内存时，会根据继承的顺序，依次调用基类的构造函数，在构造函数中，与单继承类似，在各个基类的构造中，先将虚表指针初始化为各个基类的虚表地址，然后在调用完各个基类的构造函数后将虚表指针覆盖为对象自身的虚表地址，唯一不同的是，派生类有多个虚表指针，有几个派生类就有几个虚表指针。另外派生类的内存分布与单继承的分布情况相似，根据继承顺序从低地址到高地址依次摆放，最后是派生类自己定义的部分，每个基类都会在其自身所在位置的首地址处构建一个虚表。在调用各自基类的构造函数时，并不是笼统的将对象的首地址传递给基类的构造函数，而是经过相应的地址偏移之后，将偏移后的地址传递给对应的构造。在转化为父类的指针时也是经过了相应的地址偏移。在析构时首先析构自身，然后按照与构造相反的顺序调用基类的析构函数。dynamic_cast强制类型转化与static_cast类型转化根据上面的说明我们可以简单的画一张图：这个对象中有三个虚表，分别位于各个基类所在内存的首地址处，如果我们利用多态的特性进行类型转化的话如果采用static_cast的方式会进行静态转化，也就是说它只是简单的将对象的首地址进行类型转化，这个时候如果调用CParent2的函数，在编译的时候不会报错，但是在运行时可能在虚表中（注意如果是这种情况它找到的虚表其实是CParent1的虚表）找不到想要的虚函数，这个时候调用会引起非法内存访问，造成程序崩溃。但是用dynamic_cast可以进行偏移地址的计算，自动偏移到CParent2内存部分的首地址，这个时候调用虚函数不会产生崩溃的问题。所以在有多重继承和多继承的时候尽量使用dynamic_cast进行类型转化。抽象类抽象类是不能实例化的类，只要有纯虚函数就是一个抽象类。纯虚函数是只有定义而没有实现的函数，由于虚函数的地址需要填入虚表，所以必须提供虚函数的定义，以便编译器能够将虚函数的地址放入虚表，所以虚函数必须定义，但是纯虚函数不一样，它不能定义。class CParent { public: virtual show() = 0; }; class CChild : public CParent { public: virtual show(){ printf("CChild()\n"); } }; int main() { CChild cc; CParent *p = &cc; p->show(); return 0; }上面的代码定义了一个抽象类CParent，而CChild继承这个抽象类并实现了其中的纯虚函数，在主函数中通过基类的指针掉用虚函数，形成多态。22: CChild cc; 00401288 lea ecx,[ebp-4] 0040128B call @ILT+0(CChild::CChild) (00401005) 23: CParent *p = &cc; 00401290 lea eax,[ebp-4] 00401293 mov dword ptr [ebp-8],eax 24: p->show(); 00401296 mov ecx,dword ptr [ebp-8] 00401299 mov edx,dword ptr [ecx] 0040129B mov esi,esp 0040129D mov ecx,dword ptr [ebp-8] 004012A0 call dword ptr [edx] ;CChild构造函数 004012F0 call @ILT+25(CParent::CParent) (0040101e) 004012F5 mov eax,dword ptr [ebp-4] 004012F8 mov dword ptr [eax],offset CChild::`vftable' (0042f01c) CParent构造函数 00401399 pop ecx 0040139A mov dword ptr [ebp-4],ecx 0040139D mov eax,dword ptr [ebp-4] 004013A0 mov dword ptr [eax],offset CParent::`vftable' (0042f02c) 004013A6 mov eax,dword ptr [ebp-4]构造函数中仍然是调用了基类的构造函数，并在基类的构造中对虚表指针进行了赋值，但是基类中并没有定义show函数，而是将它作为纯虚函数，那么虚表中存储的的是什么东西呢，这个位置存储的是一个_purecall函数，主要是为了防止误调纯虚函数。菱形继承菱形继承是最为复杂的一种继承方式，它结合了单继承和多继承class CGrand { public: virtual void func1(){ printf("CGrand func1()\n"); } protected: int m_nNum1; }; class CParent1 : public CGrand { public: virtual void func2(){ printf("CParent1 func2()\n"); } virtual void func3(){ printf("CParent1 func3()\n"); } protected: int m_nNum2; }; class CParent2 : public CGrand { public: virtual void func4(){ printf("CParent2 func4()\n"); } virtual void func5(){ printf("CParent2 func5()\n"); } protected: int m_nNum3; }; class CChild : public CParent1, public CParent2 { public: virtual void func2(){ printf("CChild func2()\n"); } virtual void func4(){ printf("CChild func4()\n"); } protected: int m_nNum4; }; int main() { CChild cc; CParent1 *p1 = &cc; CParent2 *p2 = &cc; return 0; }上面的代码中有4个类，其中CGrand类为祖父类，而CParent1 CParent2为父类，他们都派生自组父类，而子类继承与CParent1 CParent2，根据前面的经验可以知道sizeof(CGrand) = 4(vt) + 4(int) = 8，而sizeof(CParent1) = sizeof(CParent2) = sizeof(CGrand) + 4(int) = 12， sizeof(CChild) = sizeof(CParent1) + sizeof(CParent2) + 4(int) = 28;大致可以知道CChild对象的内存分布是CParent1 CParent2 int这种情况，通过反汇编的方式我们可以看出对象的内存分布如下：内存的分步来看，CParent1 CParent2都继承自CGrand类，所以他们都有CGrand类的成员，而CChild类继承自两个类，所以CGrand类的成员在CChild类中有两份，所以在调用m_nNum1成员时会产生二义性，编译器不知道你准备调用那个m_nNum1成员，所以一般这个时候需要指定调用的是哪个部分的m_nNum1成员。同时在转化为祖父类的时候也会产生二义性。而虚继承可以有效的解决这个问题。一般来说虚继承可以有效的避免二义性是因为重复的内容在对象中只有一份。下面对上述例子进行相应的修改，为每个类添加构造函数构造初始化这些成员变量：m_nNum1 = 1；m_nNum2 = 2； m_nNum3 = 3； m_nNum4 = 4；另外再为CParent1 CParent2类添加虚继承。这个时候我们运行程序输入类CChild的大小：sizeof(CChild) = 36；按照之前所说的同样的内容只保留的一份，那内存大小应该会减少才对，为何突然增大了8个字节呢，下面来看看对象在内存中的分步：0012FF5C 30 F0 42 000012FF60 48 F0 42 00 0012FF64 02 00 00 000012FF68 24 F0 42 000012FF6C 3C F0 42 000012FF70 03 00 00 000012FF74 04 00 00 000012FF78 20 F0 42 000012FF7C 01 00 00 00上述内存的分步与我们之前想象的有很大的不同，所有变量的确只有一份，但是总内存大小还是变大了，同时它的存储顺序也不是按照我们之前所说的父类的排在子类的前面，而且还多了一些我们并不了解的数据下面通过反汇编代码来说明这些数值的作用：;主函数部分 73: CChild cc; 004012D8 push 1;是否构造祖父类1表示构造，0表示不构造 004012DA lea ecx,[ebp-24h] 004012DD call @ILT+5(CChild::CChild) (0040100a) 74: printf("%d\n", sizeof(cc)); 004012E2 push 24h 004012E4 push offset string "%d\n" (0042f01c) 004012E9 call printf (00401a70) 004012EE add esp,8 75: CParent1 *p1 = &cc; 004012F1 lea eax,[ebp-24h] 004012F4 mov dword ptr [ebp-28h],eax 76: CParent2 *p2 = &cc; 004012F7 lea ecx,[ebp-24h] 004012FA test ecx,ecx 004012FC je main+46h (00401306) 004012FE lea edx,[ebp-18h] 00401301 mov dword ptr [ebp-34h],edx 00401304 jmp main+4Dh (0040130d) 00401306 mov dword ptr [ebp-34h],0 0040130D mov eax,dword ptr [ebp-34h] 00401310 mov dword ptr [ebp-2Ch],eax 77: CGrand *p3 = &cc; 00401313 lea ecx,[ebp-24h] 00401316 test ecx,ecx;this指针不为空 00401318 jne main+63h (00401323);不为空则跳转 0040131A mov dword ptr [ebp-38h],0 00401321 jmp main+70h (00401330) 00401323 mov edx,dword ptr [ebp-20h];edx = 0x0040f048 00401326 mov eax,dword ptr [edx+4];eax = 0x18这个可以通过查看内存获得 00401329 lea ecx,[ebp+eax-20h]; ebp + eax - 20h = 0x0012ff78, ecx = 0x0012FF78 0040132D mov dword ptr [ebp-38h],ecx;经过偏移后获得这个地址 00401330 mov edx,dword ptr [ebp-38h] 00401333 mov dword ptr [ebp-30h],edx ;CChild构造 0040135A mov dword ptr [ebp-4],ecx 0040135D cmp dword ptr [ebp+8],0 00401361 je CChild::CChild+42h (00401382) 00401363 mov eax,dword ptr [ebp-4] 00401366 mov dword ptr [eax+4],offset CChild::`vbtable' (0042f048) 0040136D mov ecx,dword ptr [ebp-4] 00401370 mov dword ptr [ecx+10h],offset CChild::`vbtable' (0042f03c) 00401377 mov ecx,dword ptr [ebp-4] 0040137A add ecx,1Ch 0040137D call @ILT+0(CGrand::CGrand) (00401005);this 指针向下偏移1ch，开始构造父类 00401382 push 0;保证父类只构造一次 00401384 mov ecx,dword ptr [ebp-4] 00401387 call @ILT+60(CParent1::CParent1) (00401041) 0040138C push 0 0040138E mov ecx,dword ptr [ebp-4] 00401391 add ecx,0Ch 00401394 call @ILT+65(CParent2::CParent2) (00401046) 00401399 mov edx,dword ptr [ebp-4] 0040139C mov dword ptr [edx],offset CChild::`vftable' (0042f030) 004013A2 mov eax,dword ptr [ebp-4] 004013A5 mov dword ptr [eax+0Ch],offset CChild::`vftable' (0042f024) 004013AC mov ecx,dword ptr [ebp-4] 004013AF mov edx,dword ptr [ecx+4] 004013B2 mov eax,dword ptr [edx+4] 004013B5 mov ecx,dword ptr [ebp-4] 004013B8 mov dword ptr [ecx+eax+4],offset CChild::`vftable' (0042f020) 57: m_nNum4 = 4; 004013C0 mov edx,dword ptr [ebp-4] 004013C3 mov dword ptr [edx+18h],4 58: } ;CGrand构造 00401429 pop ecx 0040142A mov dword ptr [ebp-4],ecx 0040142D mov eax,dword ptr [ebp-4] 00401430 mov dword ptr [eax],offset CGrand::`vftable' (0042f054);虚表指针后期会被替代 10: m_nNum1 = 1; 00401436 mov ecx,dword ptr [ebp-4] 00401439 mov dword ptr [ecx+4],1 11: } ;CParent1构造 04014C9 pop ecx 004014CA mov dword ptr [ebp-4],ecx 004014CD cmp dword ptr [ebp+8],0;不再调用祖父类构造 004014D1 je CParent1::CParent1+38h (004014e8) 004014D3 mov eax,dword ptr [ebp-4] 004014D6 mov dword ptr [eax+4],offset CParent1::`vbtable' (0042f07c) 004014DD mov ecx,dword ptr [ebp-4] 004014E0 add ecx,0Ch 004014E3 call @ILT+0(CGrand::CGrand) (00401005);这个时候会跳过这个构造函数的调用通过上面的代码可以看出，为了使得相同的内容只有一份，在程序中额外传入一个参数作为标记，用于表示是否调用祖父类构造函数，当初始化完祖父类后将此标记置0以后不再初始化，另外程序在每个父类中都多添加了一个四字节的成员用来存储一个一个偏移地址，以便能正确的将派生类转化为父类。所以每当多出一个虚继承就多了一个记录偏移量的4字节内存，所以这个类总共多出了8个字节。所以这时候的类所占内存大小为28 + 4 * 2 = 36字节。