常见的动态内存错误总结

目录

一、对NULL指针的解引用操作

二、对动态开辟空间的越界访问 

三、对非动态开辟内存使用free释放

四、使用free释放一块动态开辟内存的一部分

五、对同一块动态内存多次释放

六、动态开辟的内存未释放(内存泄漏)

七、返回栈空间地址的问题与野指针陷阱

        结论


一、对NULL指针的解引用操作

代码一  动态内存申请后未进行空指针检查

//err
void test()
{
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;    //未进行空指针判断,若p的值是NULL,就会有问题
 free(p);
}


//correct
void test()
{
 int *p = (int *)malloc(INT_MAX/4);
 if(p == NULL)    //进行返回值NULL指针检查,更为严谨
 {
    exit(-1);
 } 
  else 
 {
   *p = 20;
 }  
 free(p);
}
  • 在使用动态内存函数(malloc、calloc、reallo)申请空间后,需要进行空指针判断。因为动态内存函数申请空间有可能会失败,若开辟失败,则函数会返回一个NULL指针。因此对动态内存函数的返回值,一定要做检查。
  • 注意,free函数是允许传入NULL指针的。当free的参数为NULL指针时,函数什么事情也不做,不会出现动态内存错误。

代码二  指针变量的传值调用

*运行Test函数,结果如何?会打印出 hello world 吗?

//运行Test函数,结果如何?

void GetMemory(char *p) {
     p = (char *)malloc(100);
}

void Test(void) {
     char *str = NULL;
     GetMemory(str);
     strcpy(str, "hello world");
     printf(str);
}

答案是并不会。该程序无法正常输出,原因在于其中也有“NULL指针陷阱”。

如下图所示:

  1. 在Test函数中创建指针变量 *str,并赋值为NULL。
  2. 在Test函数中调用GetMemory函数。GetMemory函数的形参为char *p,形参是实参的临时拷贝,形参的改变不影响实参。*p与*str是两个不同的变量,存储在栈上两块完全不同的内存空间。
  3. GetMemory函数中,变量p指向了一块新开辟的内存空间,但p的改变并不影响实参*str。
  4. 由于局部变量建立在栈上,函数调用结束后,生命周期就结束,因此在GetMemory函数结束后,该函数的栈帧销毁,变量*p也随之销毁。而此时*str的值并未改变,仍然是NULL。
  5. 因此最后在Test函数中strcpy试图将字符串"hello world"拷贝到NULL指针str中,strcpy函数出错。该代码无法正常运行。

以上代码可以理解为指针的传值调用。我们知道,要在调用的函数内“远程”改变函数外的变量值,需要传入变量的地址。因此,要让上面的代码能正常打印"hello world",只需在函数中传入指针变量的地址——二级指针即可。(当然,通过返回值的方式,在函数调用后接收返回值,也是可行的。)

//correct

void GetMemory(char* *p)     //传入二级指针
{
     *p = (char *)malloc(100);    //对二级指针解引用,获得指针变量的地址,从而改变指针变量的值
}

void Test(void) {
     char *str = NULL;
     GetMemory(str);
     strcpy(str, "hello world");
     printf(str);
     free(str);
}

二、对动态开辟空间的越界访问 

void test()
{
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(NULL == p)
 {
 exit(EXIT_FAILURE);
 }

 for(i=0; i<=10; i++)
 {
 *(p+i) = i;//当i是10的时候越界访问
 }

 free(p);
}

该程序中,指针p指向一片开辟了40个字节(即10个整型)的存储空间。若要访问该空间的内存值,则0到9才是合法的下标数值。然而在遍历赋值时,i越界到了10.这时,由于访问了无权限访问的内存空间,程序就会崩溃,无法正常运行。 


三、对非动态开辟内存使用free释放

void test()
{
 int a = 10;
 int *p = &a;
 free(p);
}

以上程序中,a变量并不是动态内存开辟的。令指针p指向a的内存空间并free(p),编译器会运行出错(Debug Assertion failed)。注意:free只能释放动态开辟的内存空间。


四、使用free释放一块动态开辟内存的一部分

void test()
{
 int *p = (int *)malloc(100);
 p++;
 free(p);    //p不再指向动态内存的起始位置
}

以上程序中,原本指向动态内存开辟空间的p后来被移动,最终所指向的位置不再是开辟空间的起始位置。这时再将p释放,释放的只是部分动态开辟内存而不是全部,这样程序仍然会在运行时崩溃。

因此要注意:在动态开辟空间之后,如果要遍历开辟的内存空间,不要用开辟时接收的指针来遍历。应当再定义一个别的指针如指针q,进行运算操作。将p指针不动留到最后,用于最终的释放操作。


 

五、对同一块动态内存多次释放

void test()
{
 int *p = (int *)malloc(100);
 free(p);
 free(p);    //重复释放
}

该程序仍然会出现运行错误。在第一次free(p)后,p所指向的空间就已经被释放。此时的p相当于一个野指针,指向已经被释放了的无权限访问的内存空间。

而之后再进行一次free(p),p所指的内容已经不是动态内存开辟的空间了。因此程序会出错而中止。 

注意,若在第一次free(p)后,将p = NULL,然后再进行第二次free(p),此时不会发生任何错误。因此,在释放完动态开辟的内存后,要记得将指针赋值为NULL,使程序更加严谨,避免一时疏忽从而让程序出错。


六、动态开辟的内存未释放(内存泄漏)

代码一 

void test()
{
     int *p = (int *)malloc(100);
     if(NULL != p)
     {
         *p = 20;
     }
}

int main()
{
     test();
     while(1);
}

如上代码中,在test函数中开辟了动态内存,然而却并没有在其中释放。整个程序中都没有释放动态内存,显然造成了内存泄漏。


代码二

void GetMemory(char **p, int num) 
{
     *p = (char *)malloc(num);
}

void Test(void) 
{
     char *str = NULL;
     GetMemory(&str, 100);
     strcpy(str, "hello");
     printf(str);
}

该代码同样没有进行内存释放。应当在程序结束之前,加上free(str);    str = NULL;语句,完成“善后”工作。


七、返回栈空间地址的问题与野指针陷阱

代码一

*运行test函数,会有什么结果?能正确输字符串"hello"吗?

//运行test函数,会产生什么结果?

char *Get()
{
	char p[] = "hello";
	return p;
}

void test()
{
	char* str = NULL;
	str = Get();
	printf(str);
}

答案是不能,该代码会运行出错,因为该程序中的str指针,实际上是一个野指针。

在Get()函数中,开辟了一个字符数组p[ ]。char p[ ] 是一个临时的数组空间,里面存放了hello\0这6个字符。它是开辟在栈上的,出了函数就被销毁。

因此,虽然str接收了返回值字符数组的首元素地址p,但函数调用完毕后,由于函数栈空间销毁,数组空间已不存在。

str就成了指向无访问权限空间的野指针,在printf访问时出错。

 


结论

从函数返回一个指向临时在栈空间开辟的指针,就会有野指针访问的问题。因为在函数栈帧中创建的变量,出了函数,栈帧空间就销毁。空间销毁,而空间的地址还在使用,就会出错。

而若将char p[ ] 用static修饰,将p定义为静态变量,程序就能正常运行:

//ok
char *Get()
{
	static char p[] = "hello";	//加了static
	return p;
}

void test()
{
	char* str = NULL;
	str = Get();
	printf(str);
}

因为在函数局部变量前用static修饰,变量就成了静态变量。

加了static的变量是在静态区开辟的,不是在栈里开辟的,因此p数组的的生命周期延长,在函数调用结束后,空间也未销毁。因此,str没有成为野指针,str中保存的指针p仍然有效。此时能够正常访问,并打印出字符串"hello"。  


代码二

*运行test函数,会有什么结果?能正确输字符串"hello"吗?

//运行test函数,结果如何?

char *Get()
{
	char *p = "hello";
	return p;
}

void test()
{
	char* str = NULL;
	str = Get();
	printf(str);
}

 答案是可以。该代码能够正常运行并输出"hello"。

该代码与代码一的区别在于,char* p 指向的是一个常量字符串"hello"。常量字符串是存放在静态区而不是栈区的,因此出了Get函数内存空间也不会销毁。在test函数中仍然可以正常访问。

(注意,由于常量字符串不能被改变,因此它的首元素地址的数据类型是const char* 。p在接收时,最好也把数据类型写成const char*,否则编译器会报警告。)


代码三

*该代码正确吗?

int* test2()
{
	int a = 10;
	return &a;
}

int main()
{
	int*p  = test2();
	printf("%d\n", *p);

	return 0;
}

该代码自然是不正确。和上面的代码一一样,函数返回了局部变量的地址,造成了p的野指针问题。


代码四

*该代码正确吗?

int test2()
{
	int a = 10;
	return a;
}

int main()
{
	int p  = test2();
	printf("%d\n", p);

	return 0;
}

该代码正确。因为返回的并不是变量的地址,而是变量的值。通过寄存器,test2函数能将局部变量的返回值带入main函数的变量p中。


代码五

//运行Test函数,会有什么结果?

void Test(void) 
{
     char *str = (char *) malloc(100);
     strcpy(str, "hello");
     free(str);    //释放str
     if(str != NULL)
     {
         strcpy(str, "world");
         printf(str);
     }
}

在释放了str后,str成为野指针。str并未置NULL,进入 if 语句后,strcpy野指针非法访问,运行出错。

注意,free后必须先将指针置NULL。否则使用指针极易出现空指针访问错误!

评论 13
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值