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

最新推荐文章于 2025-07-13 09:00:00 发布

原创最新推荐文章于 2025-07-13 09:00:00 发布 · 6.8k 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#汇编 #c++ #class #编译器 #编程 #null

C/C++ 专栏收录该内容

30 篇文章

订阅专栏

本文详细分析了C++中类中指针使用不当导致内存错误的问题，并通过实例展示了问题产生的原因及解决方案。通过研究过程，读者将了解如何避免内存释放错误，以及如何正确实现拷贝构造函数以进行深复制。

指针是编程人员的梦魇，对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函数解可以正常编译通过，没有问题。

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