对于C++的内存泄漏，总结一句话：就是new出来的内存没有通过delete合理的释放掉！

一、程序循环new创建出来的对象没有及时的delete掉，导致了内存的泄露；
代码如下：

1. 
   
2. #include <iostream>
   
3. #include <new.h>
   / X9 s# e1 ^5 q% P7 T, C8 y* z
4. using namespace std;
   ( ~3 U9 V3 E3 x
5. 
   
6. void out_of_memroy()
   & ]' z$ D. Z: r' X2 Y9 N
7. {
   
8.     cout << "ERROR:内存已耗尽！" << endl;
   
9. }
   ' a# z. ?3 f1 R4 w8 D0 n7 |, l# }, Q
10. int main()
    
11. {
    
12.     set_new_handler(out_of_memroy);//注意参数传递的是函数的地址；
    2 U& T, v* Q* Q2 P/ {) O+ g
13.     while(1)
    # h1 R( P+ c( O$ N" j! ]8 M
14.     {
    , m( m0 c7 T* h/ z* \
15.         new int[1000];
    
16.     }
    7 ~+ `$ m  ?' T/ m! R6 d: G0 W
17.     return 0;
    * c( h; a( l( r
18. }

复制代码

2 ~" D- J  b6 l9 q; B* f, ?

以上代码会在堆区疯狂的动态分配内存空间，导致系统内存耗尽时自动调用set_new_handler参数列表中的函数，打印出ERROR:内存已耗尽！如下图：

二、delete掉一个void*类型的指针，导致没有调用到对象的析构函数，析构的所有清理工作都没有去执行从而导致内存的泄露；
代码如下：

1. 
   
2. class Object {
   
3. private:
   
4.     void* data;
   0 n  i! C- R6 g7 q" w
5.     const int size;
   
6.     const char id;
   ; a4 a  \. Z1 \6 [; {
7. public:
   ' o, j- i$ H7 ?- b) T
8.     Object(int sz, char c):size(sz), id(c){
   
9.     data = new char[size];
   
10.     cout << "Object() " << id << " size = " << size << endl;
    
11.     }
    ) s1 _6 ?8 Y2 @- c8 F5 S
12.     ~Object(){
    
13.     cout << "~Object() " << id << endl;
    9 C" }' k- q6 \
14.     delete []data;
      D( ^* D5 k, C: V
15.     }
    2 T8 d0 S6 ]% w" C
16. };

复制代码

紧接着使我们的main函数：

1. 
   4 }9 P( I' L; J9 l0 F
2. int main() {
   
3. Object* a = new Object(10, 'A');//Object*指针指向一个Object对象；
   3 h4 ?2 B/ y7 |3 |5 G+ I
4. void* b = new Object(20, 'B');//void*指针指向一个Object对象；
   / ~8 Q* D/ J/ p7 W) K) Z
5. delete a;//执行delete，编译器自动调用析构函数；
   + A, }5 X& x: G3 v
6. delete b;//执行delete，编译器不会调用析构函数，导致data占用内存没有得到回收；
   3 o+ S7 i& e2 a4 Y5 M. ~0 B
7. cout << "Press any key to continue... ..." << endl;
   
8. getchar();
   : i* _5 q9 E7 l+ u1 \2 A
9. return 0;
   
10. }

复制代码

执行结果如下图：

从执行结果看到，并没有执行b指针（void*）所指对象的析构函数，所以delete一个void*的指针可能会造成内存上的泄露！

三、new创建了一组对象数组，内存回收的时候却只调用了delete而非delete []来处理，导致只有对象数组的第一个对象的析构函数得到执行并回收了内存占用，数组的其他对象所占内存得不到回收，导致内存泄露；

代码如下：

1. 
   $ i" e- W2 ~' k) Q7 d5 }
2. class Object1
   1 d( V6 s8 S' B/ s1 F) c8 l5 |
3. {
   
4.     int a;
   ' S' ~$ e. H- m0 t
5.     int b;
   
6. };
   
7. 
   
8. int main() {
   0 m: P" q# a% ^; f; U6 |9 l' h% h
9. Object1* arry1 = new Object1[100];//创建包含100个Object1的对象数组arry1并返回数组首地址；
   
10. Object1* arry2 = new Object1[100];//创建包含100个Object1的对象数组arry2并返回数组首地址；
    
11. delete []arry1;//回收了数组arry1里的所有对象动态创建时占用的内存空间；
    9 n) `# K1 Y# O& z! i
12. delete  arry2;//回收了数组arry2里的第一个对象动态创建时占用的内存空间，导致其他99个对象的内存空间泄露；
    
13. 
    
14. cout << "Press any key to continue... ..." << endl;
    , T9 M2 C- z; }) g; i
15. getchar();
    0 y1 s) g9 q/ d+ C- R
16. return 0;
    
17. }

复制代码

  L% \. g4 O- R% v& D. u6 g( z
7 {- m/ d6 X. A2 n: ]9 w

谢谢分享