目录
一、对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指针陷阱”。
如下图所示:
- 在Test函数中创建指针变量 *str,并赋值为NULL。
- 在Test函数中调用GetMemory函数。GetMemory函数的形参为char *p,形参是实参的临时拷贝,形参的改变不影响实参。*p与*str是两个不同的变量,存储在栈上两块完全不同的内存空间。
- GetMemory函数中,变量p指向了一块新开辟的内存空间,但p的改变并不影响实参*str。
- 由于局部变量建立在栈上,函数调用结束后,生命周期就结束,因此在GetMemory函数结束后,该函数的栈帧销毁,变量*p也随之销毁。而此时*str的值并未改变,仍然是NULL。
- 因此最后在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。否则使用指针极易出现空指针访问错误!