从汇编的眼光看C++（之指针拷贝）

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/feixiaoxing/article/details/6827801

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

    指针是编程人员的梦魇，对C语言的开发者是如此，对C++的开发者也是如此。特别是在C++中，如果不注意处理类中的指针，非常容易出问题。如果朋友们不相信可以看看下面的代码：

 
 

   
   

    
    

   
   
   
   

    
    

     
     class 
     
     data
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int* 
     
     value;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	data(
     
     int num){
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     if(num > 
     
     0)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
			
     
     value = (
     
     int*)malloc(
     
     sizeof(
     
     int)* num);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	~data(){
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     if(
     
     value)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     			free(
     
     value);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     };
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     void process()
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     data m(10);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	data p = m;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

    上面的这段问题有没有什么问题？大家可以自己先用笔在草稿纸上面画一画。然后上机用实际环境验证一下。果不其然，系统提示内存发生了错误。为什么呢？就是因为内存发生了两次释放。我们看以看一下process的汇编代码：

 
 

   
   

    
    

   
   
   
   

    
    

     
     21:       
     
     data m(
     
     10);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     0040105D   push        
     
     0Ah
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     0040105F   lea         ecx,[ebp
     
     -10h]
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     00401062   call        
     
     @ILT+
     
     15(
     
     data::
     
     data) (
     
     00401014)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     00401067   mov         dword ptr [ebp
     
     -4],
     
     0
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     22:       
     
     data p = m;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     0040106E   mov         eax,dword ptr [ebp
     
     -10h]
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     00401071   mov         dword ptr [ebp
     
     -14h],eax
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     23:   }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     00401074   lea         ecx,[ebp
     
     -14h]
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     00401077   call        
     
     @ILT+
     
     5(
     
     data::~
     
     data) (
     
     0040100a)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     0040107C   mov         dword ptr [ebp
     
     -4],
     
     0FFFFFFFFh
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     00401083   lea         ecx,[ebp
     
     -10h]
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     00401086   call        
     
     @ILT+
     
     5(
     
     data::~
     
     data) (
     
     0040100a)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     0040108B   mov         ecx,dword ptr [ebp
     
     -0Ch]
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     0040108E   mov         dword ptr fs:[
     
     0],ecx
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     00401095   pop         edi
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     00401096   pop         esi
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     00401097   pop         ebx
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     00401098   add         esp,
     
     54h
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     0040109B   cmp         ebp,esp
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     0040109D   call        __chkesp (
     
     004015b0)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     004010A2   mov         esp,ebp
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     004010A4   pop         ebp
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     004010A5   ret
    
    
   
   
 
 

    21行： data调用构造函数，分配内存给value

    22行： 这里我们发现程序进行内存拷贝，那么表示m变量value的数值和p变量中value的数值是一样的

    23行：这里函数即将结束，所以系统调用m和p的析构函数，第一次析构的时候value指向的内存被释放，第二次析构的时候由于p变量value的数值非0，所以也需要释放内存，当然也需要进行析构处理，但是此时内存已经释放了，所以内存进行了二次释放，系统报错。

 

    经过上面的研究，我们发现了问题和原因，那么应该怎么解决呢？既然问题是在拷贝函数这里，那么就要对拷贝函数进行特殊处理。目前就我个人理解，有两个方法供大家选择：

    （1）对拷贝构造函数进行private处理，这样一旦出现了拷贝操作，编译器就会提示出错。

 
 

   
   

    
    

   
   
   
   

    
    

     
     class 
     
     data
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int* 
     
     value;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	data(
     
     const data&) ;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	data(
     
     int num){
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     if(num > 
     
     0)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
			
     
     value = (
     
     int*)malloc(
     
     sizeof(
     
     int)* num);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	~data(){
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     if(
     
     value)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     			free(
     
     value);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     };
    
    
   
   
 
 

     （2）编写拷贝构造函数，进行内存深复制

 
 

   
   

    
    

   
   
   
   

    
    

     
     class 
     
     data
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int* 
     
     value;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int number;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	data(
     
     int num){
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     if(num > 
     
     0)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
			
     
     value = (
     
     int*)malloc(
     
     sizeof(
     
     int)* num);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		number = num;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	data(
     
     const data& d){
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     if(NULL != d.get_ptr())
    
    
   
   

   
   

    
    

   
   
   
   

    
    
			
     
     value = (
     
     int*) malloc(
     
     sizeof(
     
     int)* d.get_number());
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		number = d.get_number();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		memmove(
     
     value, d.get_ptr(), 
     
     sizeof(
     
     int)* number);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	~data(){
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     if(
     
     value)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     			free(
     
     value);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int* get_ptr() 
     
     const{ 
     
     return 
     
     value;}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int get_number() const {
     
     return number;}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     };
    
    
   
   
 
 

    我们看到，经过拷贝构造函数的定义后，原来的process函数解可以正常编译通过，没有问题。
    

【预告： 下一篇介绍复制运算符中的陷阱】