我们的这款游戏从开发到上线至今已有大概4年了，昨天发现代码中有new出来的对象没有delete，程序退出后VS输出栏中居然没有提示，难道程序中没有内存泄漏检察？进一步的求证确定了我的担忧（我是半路进的项目组）。在代码中加上_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF)后，VS的输出栏赫然显示了大量的内存泄漏。在动手解决内存泄漏之前，先复习一下有关new操作符重载的相关知识：

new 操作符按其可见性可分为全局的与局部的(类成员)，我们可以对他们进行重载，下面是VS 2010中new.cpp中new操作符的声明

调用new时，传入的参数比new声明时的参数少了一个，即第一个参数，该参数是new的对象的大小，由编译器填写，禁止程序员自己插手。

对一个类重载new和delete

当我们new一个自定义类时，如果该类重载了new操作符，则优先使用该类内部定义的new，如果这时非要调用全局的new操作符怎么办呢？可以在new前面加两个冒号:

下面回到解决内存泄漏的步骤上：

1 在程序必定会执行的路径上加上：

不一定非得是程序的最开始处

2 使用上面给出的第2个new操作符，当程序退出时，它会在VS输出栏中注明是哪行代码引起的内存泄漏。即所有的new 都改为

完了。。。。。这样就可以了。

但是，我们程序已有的代码都写的是new，而不是new ( _NORMAL_BLOCK, __FILE__, __LINE__ )。

MFC中的解决方法：

这样好像是可以解决问题，但是我们游戏中用了Gamebryo游戏引擎，这个引擎中很多类内部重载了new操作符，并且还有如下的宏定义：

并且引擎自带的对象都是通过NiNew来创建的，如 NiNew NiAlphaProperty();

如果我们把new 宏定义成了new ( _NORMAL_BLOCK, __FILE__, __LINE__ )，那么碰到NiNew NiAlphaProperty()后，代码就被展开成为

new ( _NORMAL_BLOCK, __FILE__, __LINE__ )  ( NI_MEMHINT_NONE, __FILE__, __LINE__ , __FUNCTION__ ) NiAlphaProperty(); 当编译器尝试着用此代码与NiAlphaProperty类内部定义的new操作符去匹配时就抓瞎了，只能报错。

目前就只能自己再定义一个宏:

将代码中所有的new替换成New。

另一种内存泄漏检测方法就是借用第3方的库:
Visual Leak Detector 是一个不错的泄漏检测库，下载地址：
http://vld.codeplex.com/releases/view/82311
只需要在自己的程序的main函数所在的文件中#include <vld.h>就可以了，使用起来很方便。

(注: _CrtSetBreakAlloc()对大型的C++工程不太实用 )

class my_class { public :     my_class()     {         m_member = 1;     }       void method(int n)     {         m_member = n;     }       ~my_class()     {         m_member = 0;     }   private :     int m_member; };   int _tmain(int argc, _TCHAR* argv[]) {     my_class a_class;     a_class.method(10);       return 0; }

_TEXT SEGMENT _wmain      PROC       push ebp                                 ; 保存旧的ebp       mov   ebp, esp                            ; ebp保存当前栈的位置       push -1                                  ; 建立SEH(Structured Exception Handler)链                                                 ; -1表示表头,没有Prev       push __ehhandler$_wmain                  ; SEH异常处理程序的地址       mov   eax, DWORD PTR fs:0                 ; fs:0指向TEB的内容，头4个字节是当前SEH链的地址       push eax                                 ; 保存起来       sub   esp, d8H                            ; 分配d8H字节的空间       push ebx       push esi       push edi       lea   edi, DWORD PTR [ebp-e4H]            ; e4H = d8H + 4 * 3，跳过中间ebx, esi, edi       mov   ecx, 36H                            ; 36H*4H=d8H，也就是用36H个ccccccccH填满刚才分配的d8H字节空间       mov   eax, ccccccccH       rep stosd       mov   eax, DWORD PTR ___security_cookie         xor   eax, ebp                       push eax                                 ; ebp ^ __security_cookie压栈保存       lea   eax, DWORD PTR [ebp-0cH]            ; ebp-0cH是新的SEH链的结构地址（刚压入栈中的栈地址）       mov   DWORD PTR fs:0, eax                 ; 设置到TEB中作为当前Active的SEH链表末尾

Security cookie after XOR

Edi

Esi

Ebx

Local stack: d8H

Old fs:0

__ehhandler$_wmain

ffffffffH

Old ebp

lea   ecx, DWORD PTR [ebp-14H]    call ??0my_class@@QAE@XZ                 ; 调用my_class::my_class, ??my_class@@QAE@XZ是经过Name Mangling后的名字    mov   DWORD PTR [ebp-4], 0                ; 进入__try块，在Main中有一个隐式的__try/__except块

push 10                                  ; 参数入栈       lea   ecx, DWORD PTR [ebp-14H]            ; 遵循thiscall调用协定，ecx存放的是this指针       call ?method@my_class@@QAEXH@Z           ; 调用子程序my_class:method(10)

mov   DWORD PTR [ebp-e0H], 0             ; 用来放置返回值       mov   DWORD PTR [ebp-4], -1               ; 标记TRY的正常结束       lea   ecx, DWORD PTR [ebp-14H]            ; a_class的地址作为this存入ECX       call ??1my_class@@QAE@XZ                 ; my_class::~my_class       mov   eax, DWORD PTR [ebp-e0H]            ; 返回值按照约定放入eax中

push edx       mov   ecx, ebp       push eax       lea   edx, DWORD PTR $LN7@wmain       call @_RTC_CheckStackVars@8             ; 检查栈       pop   eax       pop   edx       mov   ecx, DWORD PTR [ebp-0cH]            ; 取出之前保存的旧的fs:0，并恢复       mov   DWORD PTR fs:0, ecx       pop   ecx       pop   edi       pop   esi       pop   ebx       add   esp, e4H                            ; 退掉分配的d8H + 建立SEH链所需的0cH字节       cmp   ebp, esp       call __RTC_CheckEsp                      ; 检查esp值，这个时候esp应该和ebp匹配，否则说明出现了栈不平衡的情况，这种情况下调用子程序报错       mov   esp, ebp                            ; 恢复ebp到esp       pop   ebp                                 ; 恢复原来的ebp值       ret   0 _wmain      ENDP

Text$x      SEGMENT __unwindfunclet$_wmain$0:                       ; 当SEH发生的时候会调用该函数，析购a_class       lea   ecx, DWORD PTR [ebp-14H]            ; ecx = [ebp – 14H]，也就是a_class的地址       jmp   ??1my_class@@QAE@XZ                 ; 调用my_class::~my_class __ehhandler$_wmain:       mov   edx, DWORD PTR [esp+8]             ; esp = 当前的fs:0, [esp + 8] = 之前的SEH结构，也就是main中建立的       lea   eax, DWORD PTR [edx+0cH]            ; edx + 0Ch = 当前的ebp，也就是main的ebp，此时不能直接使用ebp因为可能会从任意函数调过来，此时ebp是该函数的ebp，而不是main的ebp       mov   ecx, DWORD PTR [edx-e0H]            ; 之前存下去的__security_cookie ^ ebp       xor   ecx, eax                            ; 再次和ebp相异或       call @__security_check_cookie@4          ; 此时ecx应该等于__security_cookie，否则说明栈的内容被恶意改动（或者编程错误）       mov   eax, OFFSET __ehfuncinfo$_wmain       jmp   ___CxxFrameHandler3 text$x      ENDS

_TEXT SEGMENT ??0my_class@@QAE@XZ PROC       push ebp                                 ; 保存旧的ebp       mov   ebp, esp                            ; ebp保存当前栈的位置       sub   esp, ccH                            ; 给栈分配ccH个字节       push ebx                                 ; 保存常用寄存器       push esi       push edi       push ecx       lea   edi, DWORD PTR [ebp-ccH]            ; 从分配的位置开始       mov   ecx, 33H                            ; 写33H个ccccccccH       mov   eax, ccccccccH                      ; 也就是33H*4H=ccH，正好是分配的大小       rep stosd                                 ; 从而把整个栈上当前分配的空间用ccH填满       pop   ecx       mov   DWORD PTR [ebp-8], ecx             ; 按照约定，一般用ECX保存this指针                                                 ; 把this存入到ebp-8，并不是很必要，因为这是Debug版本                                                   ; 10   :     { ; 11   :         m_member = 1;         mov   eax, DWORD PTR [ebp-8]             ; eax中存放this       mov   DWORD PTR [eax], 1                  ; this的头四个byte是m_member的内容   ; 12   :     }         mov   eax, DWORD PTR [ebp-8]             ; 多余的一句话，可以优化掉       pop   edi       pop   esi       pop   ebx       mov   esp, ebp                            ; 恢复esp，因此就算是中间栈运算出错，最后也不会导致灾难性的结果，只要ebp还是正确的       pop   ebp       ret   0 ??0my_class@@QAE@XZ ENDP

_TEXT SEGMENT ?method@my_class@@QAEXH@Z PROC                  ; my_class::method   ; 15   :     {         push ebp       mov   ebp, esp       sub   esp, ccH       push ebx       push esi       push edi       push ecx       lea   edi, DWORD PTR [ebp-ccH]       mov   ecx, 33H       mov   eax, ccccccccH       rep stosd       pop   ecx       mov   DWORD PTR [ebp-8], ecx   ; 16   :         m_member = n;         mov   eax, DWORD PTR [ebp-8]             ; eax中存放this       mov   ecx, DWORD PTR [ebp+8]             ; ebp -> ebp                                                 ; ebp + 4 -> IP                                                 ; ebp + 8 -> n                                                 ; 把n存入ecx中       mov   DWORD PTR [eax], ecx                ; this头四个字节是m_member, 因此这句话就是m_member = n   ; 17   :     }         pop   edi       pop   esi       pop   ebx       mov   esp, ebp       pop   ebp       ret   4                                   ; 等价于                                                 ; ret 恢复EIP，返回调用地址                                                 ; add esp, 4 -> 把n从栈上Pop掉 ?method@my_class@@QAEXH@Z ENDP

_TEXT SEGMENT ??1my_class@@QAE@XZ PROC                        ; my_class::~my_class   ; 20   :     {         push ebp       mov   ebp, esp       sub   esp, 204                            push ebx       push esi       push edi       push ecx       lea   edi, DWORD PTR [ebp-204]       mov   ecx, 33H                            mov   eax, ccccccccH                      rep stosd       pop   ecx       mov   DWORD PTR _this$[ebp], ecx   ; 21   :         m_member = 0;         mov   eax, DWORD PTR [ebp-8]       mov   DWORD PTR [eax], 0   ; 22   :     }         pop   edi       pop   esi       pop   ebx       mov   esp, ebp       pop   ebp       ret   0 ??1my_class@@QAE@XZ ENDP                        ; my_class::~my_class

　　实例一:
　　#include "stdafx.h"
　　#include <iostream.h>

　　class CB
　　{
　　public:
 　　　　void f(int)
 　　　　{
 　　　　　　 cout << "CB::f(int)" << endl;
　　　　 }

　　};

　　class CD : public CB
　　{
　　public:
　　　　 void f(int,int)
 　　　　{
  　　　　　　cout << "CD::f(int,int)" << endl;
 　　　　}

 　　　　void test()
 　　　　{
  　　　　　f(1);
 　　　　}
　　};

　int main(int argc, char* argv[])
　{
　　　 return 0;
　}
编译了一下
error C2660: 'f' : function does not take 1 parameters

结论：在类CD这个域中，没有f(int)这样的函数，基类中的void f(int)被隐藏

　　如果把派生CD中成员函数void f(int,int)的声明改成和基类中一样，即f(int)，基类中的void f(int)还是一样被覆盖，此时编译不会出错，在函数中test调用的是CD中的f(int)　

　　所以，在基类中的某些函数，如果没有virtral关键字，函数名是f(参数是什么我们不管)，那么如果在派生类CD中也声明了某个f成员函数，那么在类CD域中，基类中所有的那些f都被隐藏。
　　如果你比较心急，想知道什么是隐藏，看文章最后的简单说明，不过我建议你还是一步一步看下去。

　　我们刚才说的是没有virtual的情况，如果有virtual的情况呢？？
　　实例二：

#include "stdafx.h"
#include <iostream.h>

class CB
{
public:
 　　virtual void f(int)
 　　{
  　　　　cout << "CB::f(int)" << endl;
 　　}

};

class CD : public CB
{
public:
　　 void f(int)
 　　{
  　　　　cout << "CD::f(int)" << endl;
　　 }

};

int main(int argc, char* argv[])
{
 　return 0;
}

　　这么写当然是没问题了，在这里我不多费口舌了，这是很简单的，多态，虚函数，然后什么指向基类的指针指向派生类对象阿，通过引用调用虚函数阿什么的，属性多的很咯，什么？？你不明白？？随便找本C++的书，对会讲多态和虚函数机制的哦！！
　　这种情况我们叫覆盖(override)！覆盖指的是派生类的虚拟函数覆盖了基类的同名且参数相同的函数！
　　在这里，我要强调的是，这种覆盖，要满足两个条件
　(a)有virtual关键字，在基类中函数声明的时候加上就可以了
　(b)基类CB中的函数和派生类CD中的函数要一模一样，什么叫一模一样，函数名，参数，返回类型三个条件。
　　有人可能会对(b)中的说法质疑，说返回类型也要一样？？
　　是，覆盖的话必须一样，我试了试，如果在基类中,把f的声明改成virtual int f(int)，编译出错了
　　error C2555: 'CD::f' : overriding virtual function differs from 'CB::f' only by return type or calling convention
　　所以，覆盖的话，必须要满足上述的(a)(b)条件

　　那么如果基类CB中的函数f有关键字virtual　，但是参数和派生类CD中的函数f参数不一样呢，
实例三:
  #include "stdafx.h"
#include <iostream.h>

class CB
{
　public:
 　　 virtual  void f(int)
　　 {
 　　　　 cout << "CB::f(int)" << endl;
　　 }

}
;

class CD : public CB
{
public:
 　　 void f(int，int)
 　　{
 　　　 cout << "CD::f(int，int)" << endl;
 　　}

 　　void test()
 　　{
 　　　　 f(1);
 　　}
}
;

int main(int argc, char* argv[])
{
 return 0;
}

编译出错了，
 error C2660: 'f' : function does not take 1 parameters
　　咦？？好面熟的错？？对，和实例一中的情况一样哦，结论也是基类中的函数被隐藏了。

　　通过上面三个例子，得出一个简单的结论
如果基类中的函数和派生类中的两个名字一样的函数f
满足下面的两个条件
(a)在基类中函数声明的时候有virtual关键字
(b)基类CB中的函数和派生类CD中的函数一模一样，函数名，参数，返回类型都一样。
那么这就是叫做覆盖(override)，这也就是虚函数，多态的性质

那么其他的情况呢？？只要名字一样，不满足上面覆盖的条件，就是隐藏了。

下面我要讲最关键的地方了，好多人认为，基类CB中的f(int)会继承下来和CD中的f(int,int)在派生类CD中构成重载，就像实例一中想像的那样。
　　对吗？我们先看重载的定义
　　重载(overload):
　　必须在一个域中,函数名称相同但是函数参数不同,重载的作用就是同一个函数有不同的行为,因此不是在一个域中的函数是无法构成重载的,这个是重载的重要特征
　　必须在一个域中，而继承明显是在两个类中了哦，所以上面的想法是不成立的，我们测试的结构也是这样，派生类中的f(int,int)把基类中的f(int)隐藏了
　　所以，相同的函数名的函数，在基类和派生类中的关系只能是覆盖或者隐藏。

　　在文章中，我把重载和覆盖的定义都给了出来了，但是一直没有给隐藏的定义，在最后，我把他给出来，这段话是网上google来的，比较长，你可以简单的理解成，在派生类域中，看不到基类中的那个同名函数了，或者说，是并没有继承下来给你用，呵呵，如实例一　那样。
　　

隐藏(hide):
指的是派生类的成员函数隐藏了基类函数的成员函数.隐藏一词可以这么理解:在调用一个类的成员函数的时候,编译器会沿着类的继承链逐级的向上查找函数的定义,如果找到了那么就停止查找了,所以如果一个派生类和一个基类都有同一个同名(暂且不论参数是否相同)的函数,而编译器最终选择了在派生类中的函数,那么我们就说这个派生类的成员函数"隐藏"了基类的成员函数,也就是说它阻止了编译器继续向上查找函数的定义.