从汇编的眼光看C++（之delete内存泄露）

最新推荐文章于 2022-04-28 23:31:19 发布
最新推荐文章于 2022-04-28 23:31:19 发布
阅读量121 收藏
点赞数
分类专栏： C/C++ 汇编语言
原文链接：https://blog.csdn.net/feixiaoxing/article/details/6823809
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/feixiaoxing/article/details/6823809

【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】


    有过C语言编程的朋友大多知道，如果在malloc内存之后不及时free掉内存，那么很有可能会造成内存泄露的。那么在C++上面，是不是也存在这样的问题呢？结果是C++上面同样也存在内存泄露的危险。这个危险就是如果new后面不能delete的话，也会造成内存的泄露。还有不清楚的朋友可以看看下面的示例：


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     class 
     
     test
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     int data;
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     public:
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	test(
     
     int 
     
     value):data(
     
     value) {}
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	~test() {};
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     };
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     void process()
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	test* t = 
     
     new test(
     
     0);
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     if(
     
     /* some errors happens */)
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	{
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return;
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  17. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  18. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	delete t;
    
    
    
   
   
  19. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return;
    
    
    
   
   
  20. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    上面的代码在一定程度上说明了问题。其实上面这段代码在函数返回的时候已经考虑到了内存删除的问题，但是关键是如果在error发生的时候，没有及时处理的话也会造成内存泄露的。那么有没有什么好的方法呢？大家可以看看C++有没有什么性质可以保证函数在结束的时候可以自动完成资源的释放。对，那就是析构函数。所以，一般的话我们可以添加一个额外的类定义。 


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     class auto_point
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	test* t;
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     public:
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	auto_point(test* p) : t(p) {}
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	~auto_point() { 
     
     if(t) 
     
     delete t;}
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     };
    但是，原来我们的好多操作都是按照指针进行的，那么怎么把类转变成指针呢？那就只有使用算术符重载了。 


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     class auto_point
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	test* t;
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     public:
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	auto_point(test* p) : t(p) {}
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	~auto_point() { 
     
     if(t) delete t;}
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	test* 
     
     operator->() { 
     
     return t;}
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	const test& 
     
     operator* () {
     
     return *t;}
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     };

    那么有了这样的一个定义之后，我们应该怎么使用呢？大家可以看看下面的函数调用：


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     22:       auto_point p(new test(0));
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010AD   push        4
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010AF   
     
     call        
     
     operator 
     
     new (
     
     00401300)
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010B4   
     
     add         esp,
     
     4
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010B7   mov         dword ptr [ebp
     
     -18h],eax
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010BA   mov         dword ptr [ebp
     
     -4],
     
     0
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010C1   cmp         dword ptr [ebp
     
     -18h],
     
     0
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010C5   je          process+
     
     56h (
     
     004010d6)
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010C7   push        
     
     0
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010C9   mov         ecx,dword ptr [ebp
     
     -18h]
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010CC   
     
     call        @ILT+
     
     80(
     
     test::
     
     test) (
     
     00401055)
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010D1   mov         dword ptr [ebp
     
     -1Ch],eax
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010D4   jmp         process+
     
     5Dh (
     
     004010dd)
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010D6   mov         dword ptr [ebp
     
     -1Ch],
     
     0
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010DD   mov         eax,dword ptr [ebp
     
     -1Ch]
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010E0   mov         dword ptr [ebp
     
     -14h],eax
    
    
    
   
   
  17. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010E3   mov         dword ptr [ebp
     
     -4],
     
     0FFFFFFFFh
    
    
    
   
   
  18. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010EA   mov         ecx,dword ptr [ebp
     
     -14h]
    
    
    
   
   
  19. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010ED   push        ecx
    
    
    
   
   
  20. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010EE   lea         ecx,[ebp
     
     -10h]
    
    
    
   
   
  21. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010F1   
     
     call        @ILT+
     
     65(auto_point::auto_point) (
     
     00401046)
    
    
    
   
   
  22. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010F6   mov         dword ptr [ebp
     
     -4],
     
     1
    
    
    
   
   
  23. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     23:       
     
     if(
     
     1
     
     /* some errors happens */)
    
    
    
   
   
  24. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004010FD   mov         edx,
     
     1
    
    
    
   
   
  25. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     00401102   
     
     test        edx,edx
    
    
    
   
   
  26. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     00401104   je          process+
     
     97h (
     
     00401117)
    
    
    
   
   
  27. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     24:       {
    
    
    
   
   
  28. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     25:           
     
     return;
    
    
    
   
   
  29. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     00401106   mov         dword ptr [ebp-4],0FFFFFFFFh
    
    
    
   
   
  30. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     0040110D   lea         ecx,[ebp-10h]
    
    
    
   
   
  31. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     00401110   
     
     call        @ILT+
     
     75(auto_point::~auto_point) (
     
     00401050)
    
    
    
   
   
  32. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     00401115   jmp         process+
     
     0A6h (
     
     00401126)
    
    
    
   
   
  33. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     26:       }
    
    
    
   
   
  34. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     27:
    
    
    
   
   
  35. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     28:       
     
     return;
    
    
    
   
   
  36. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     00401117   mov         dword ptr [ebp-4],0FFFFFFFFh
    
    
    
   
   
  37. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     0040111E   lea         ecx,[ebp-10h]
    
    
    
   
   
  38. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     00401121   
     
     call        @ILT+
     
     75(auto_point::~auto_point) (
     
     00401050)
    
    
    
   
   
  39. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     29:   }
    大家可以从上面的代码看得很清楚，不管代码在什么时候退出，函数都会利用类的基本特性，自动调用类的析构函数，那么进而内存就会得到释放，不会发生内存泄露的问题。但是我们发现上面的解决方案也有不足的地方，就是每一个类都需要额外定义一个额外的定义类。那么有没有什么办法解决这一问题呢？那就是模板了。 


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     template <
     
     typename type>
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     class auto_point
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	type* t;
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     public:
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	auto_point(type* p) : t(p) {}
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	~auto_point() { 
     
     if(t) 
     
     delete t;}
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	test* 
     
     operator->() { 
     
     return t;}
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     const test& 
     
     operator* () {
     
     return *t;}
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     };
    如果我们的类型不是特定的，那么我们只需要在使用的时候按照特定的类型输入即可。



【预告： 下面的一篇博客会介绍类成员指针拷贝的问题】


石上清泉80
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++中的delete加深认识
Stephen___Qin的博客
09-28 264
delete操作: 我们在删除一个指针之后，编译器只会释放该指针所指向的内存空间，而不会删除这个指针本身。 1.假如你不去释放，那么该区域的内存始终不能被其他数据所使用。2.指向该内存的指针是个局部变量，当定义给指针的函数结束并返回时，指针也就消失了，那么就再也找不到该块的内存区域。假如指向该内存区域的指针自动消失了，计算机就再也找不到该区域的内存了，就好像丢了这块内存一样，这种情况称为“内存泄...
C++ 内存分配和new delete的使用
qq_36458461的博客
02-23 495
内存划分 在C++中内存分为5个区，分别是堆、栈、全局/静态存储区、常量存储区和代码区。 栈：保存局部变量。栈空间用来存放函数运行时的参数值和局部变量，当一个函数运行结束时，在这个函数中声明的局部变量也会自动销毁。栈的特点是无需人工管理但空间大小有限。 堆：由malloc(C++程序员因避免使用)或者new运算符分配的内存。其生命周期由free(和malloc对应)或delete(释放new分配的空间)决定。堆中占用的空间在没有释放之前会一直存在，直到程序结束。堆的特点是自由度高，空间比较大，但程序员必须通
分析new
南宫封清的博客
12-16 236
大部分的C++开发者在他们的代码中会广泛的使用STL。如果你直接用STL和Visusal Studio 6.0，那么你的程序将在内存很低的情况下极有可能崩溃掉。原因在于没有对new操作的结果进行检验。更糟的是，若new操作确实失败了，得到的反馈也没有一个标准可言——有的编译器会返回空指针，而有的会抛出异常。 #include <new> auto p = new (std::...
C++new和delete实现原理
热门推荐
passion_wu128的专栏
09-01 2万+
new操作 delete操作 new[]操作 delete[]操作
从汇编看c++的虚拟继承以及其内存布局
12-22
从汇编代码中，我们可以看到对象的内存布局在编译期间就已经确定，成员变量的偏移量是固定的。例如，`b.l`和`bp->l`的偏移都是16字节，这意味着无论通过对象本身还是指针访问，成员变量的位置都是相同的。 对于虚拟...
用汇编的眼光看C/C++之深入指针
07-16
C语言 指针
从汇编看c++中的多态
12-22
在c++中，当一个类含有虚函数的时候，类具有了多态性。构造函数的一项重要功能是初始化vptr指针，这是保证多态性的关键步骤。 　构造函数初始化vptr指针 　下面是c++源码： class X { private:  int i; ...
从汇编看c++中默认构造函数的使用分析
09-05
然而，从汇编层面来看，这个过程并非总是涉及实际的函数调用。下面我们将深入探讨这一点。 首先，我们看一个简单的例子，类`X`只有一个`int`类型的成员变量`i`： ```cpp class X { private: int i; }; int main...
从汇编看c++中多态的应用
12-26
在c++中，当一个类含有虚函数的时候，类就具有了多态性。构造函数的一项重要功能就是初始化vptr指针，这是保证多态性的关键步骤。构造函数初始化vptr指针下面是c++源码: 代码如下:class X {private: int i;public:...
从汇编看c++的new和delete
chaoguo1234的专栏
07-27 178
下面是c++源码: class X { private: int _x; public: X(int xx = 0) : _x(xx) {} ~X() {} }; int main() { X* xp = new X; delete xp; } 代码很简单，在main函数里面先用new构造一个堆对象，...
【C++】-- 内存管理new和delete详解
局部变量和全局变量
04-28 6936
new和delete是C++向内存申请空间和释放空间的操作符：（1）new会调用构造函数对类对象进行初始化；（2）delete会调用析构函数进行资源清理
c++ new,delete,析构函数原理，汇编展示
sam的学习家园
07-19 3128
479:  String2* str2 = new String2;00401821 6A 10            push        10h  00401823 E8 C8 03 00 00   call        operator new (401BF0h) 00
Win32汇编——内存管理
kisbuddy
08-14 3427
一、内存管理基础 1.Windows的内存分层管理图： 2.不同内存管理函数的操作对象图： 3.GlobalMemoryStatus函数通过MEMORYSTATUS结构获取系统内存信息，示例代码如下： .const szInfo db '物理内存总数
C++ 内存泄漏以及delete 和 delete []的真正区别
坚持硬核
09-13 1420
c++中对new申请的内存的释放方式有delete和delete[两种方式，到底这两者有什么区别呢？ 1.我们通常从教科书上看到这样的说明： delete 释放new分配的单个对象指针指向的内存 delete[] 释放new分配的对象数组指针指向的内存 那么，按照教科书的理解，我们看下下面的代码： int *a = new int[10]; delete a; //方式1 del...
C++ 内存管理中内存泄漏问题产生原因以及解决方法
Linuxhus的博客
03-10 7410
C++内存管理中内存泄露（memory leak）一般指的是程序在申请内存后，无法释放已经申请的内存空间，内存泄露的积累往往会导致内存溢出。 一、内存分配方式 通常内存分配方式有以下三种： （1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。 （2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
C++造成内存泄漏的原因
请叫我皮皮虾的博客
10-14 678
一、程序循环new创建出来的对象没有及时的delete掉，导致了内存的泄露； 二、delete掉一个void*类型的指针，导致没有调用到对象的析构函数，析构的所有清理工作都没有去执行从而导致内存的泄露； 三、new创建了一组对象数组，内存回收的时候却只调用了delete而非delete []来处理，导致只有对象数组的第一个对象的析构函数得到执行并回收了内存占用，数组的其他对象所占内存得不到回收...
C++ delete自定义数据库类型导致内存泄露
csenjoy的博客
03-14 378
一, 问题场景 代码中使用自定义数据类型时，为了提高入参，出参普遍性。使用了void *指针类型管理入参出参。当释放内存时没有指定指针指向的类型，从而导致内存泄露。 typedef std::shared_ptr&lt;SPIWorker&gt; SPIWorker; typedef std::weak_ptr&lt;SPIWorker&gt; WPIWorker; typedef ...
C++内存泄露几种常见原因
jusu10的博客
03-13 6028
在cpp编程中，产生内存泄漏的主要原因是利用malloc或者new等分配内存的方式申请内存后，由于主观或者客观原因没有进行释放，导致申请的内存区域没有及时得到释放导致的。 下面对几种常见/特殊的情况进行简单记录。 1. 析构函数中未匹配地释放内存 2. 基类的析构函数没有设为虚函数， 由于基类的析构函数不是虚函数，在实现多态时，通过delete删除指向派生类的基类指针时，派生类的析构函数被覆盖无法调用，而是调用的基类的析构函数，导致派生类对象无法被释放，导致内存泄漏。 3. 关于指针数组释放 对

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值