6 野指针
指向位置不可知的(随机的、不正确的、没有明确限制的)的指针称为野指针。
6.1 野指针成因
6.1.1 指针未初始化
#include <stdio.h>
int main()
{
int* p;//局部变量指针未初始化,默认为随机值
*p = 20;
return 0;
}
运行结果:
6.1.2 指针越界访问
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
int* p = &arr[0];
int i = 0;
for (i = 0; i <= 11; i++)
{
//当指针指向的范围超出数组arr的范围时,p就是野指针
*(p++) = i;
}
return 0;
}
运行结果:
6.1.3 指针指向的空间被释放
例:
#include <stdio.h>
int* test()
{
int n = 100;
return &n;
}
int main()
{
int* p = test();
printf("%d\n", *p);
return 0;
}
输出结果:
上述代码虽然能够正常运行,但是test函数返回的是局部变量n的地址,当test执行完毕的时候变量n的空间就被释放了,此时如果把n的地址传给p,后续再通过p赋值的时候就会造成非法访问。即指针不能指向那些已经被释放了的空间。
6.2 如何规避野指针
6.2.1 指针初始化
如果明确知道指针指向哪里就直接赋值地址,如果不知道指针应该指向哪里,可以给指针赋值 NULL。
NULL 是C语言中定义的一个标识符常量,值为0,0也是地址,但这个地址无法使用,读写该地址时会报错。
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
例:
#include <stdio.h>
int main()
{
int num = 10;
int* p1 = #
int* p2 = NULL;//空指针
printf("%zd\n", p1);
printf("%zd\n", p2);
return 0;
}
输出结果:
6.2.2 小心指针越界
一个程序向内存申请了哪些空间,通过指针也就只能访问哪些空间,不能超出访问范围,超出了就是越界访问。
6.2.3 及时置NULL
当指针变量指向一块区域时,我们可以通过指针访问该区域,后期不再使用这个指针访问空间时,可以把该指针置为 NULL ,因为一个约定俗成的规则是:只要是 NULL 指针就不去访问,同时使用指针之前也要判断指针是否为 NULL 。
例:
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = &arr[0];
for (int i = 0; i < 10; i++)
{
*(p++) = i;
}
printf("%zd\n", p);
//此时p已经越界了,可以把p置为NULL
p = NULL;
printf("%zd\n", p);
//下次使⽤的时候,判断p不为NULL的时候再使⽤
//...
p = &arr[0];//重新让p获得地址
printf("%zd\n", p);
if (p != NULL) //判断
{
//...
}
return 0;
}
输出结果:
6.2.4 避免返回局部变量的地址
例:
#include <stdio.h>
int* test()
{
//局部变量
int arr[10] = { 1,2,3,4,5,6,7,8,9 };
//...
return arr;
}
int main()
{
int* p = test();//p就是野指针
return 0;
}
7 assert断言
assert.h 头文件定义了宏 assert(),用于在运行时确保程序符合指定条件,如不符合,就报错并终止运行。这个宏常常被称为“断言”。
assert(p != NULL);
当程序运行到上面这条语句时,会验证指针变量p是否等于 NULL ,如果不等于 NULL ,程序就可以继续运行,否则就会终止运行,并且给出报错信息提示。
assert() 宏接受一个表达式作为参数。如果该表达式为真(返回值非零),assert() 不会产生任何作用,程序继续运行。如果该表达式为假(返回值为0),assert() 就会报错,在屏幕上写入一条错误信息,显示没有通过的表达式,以及包含这个表达式的文件名和行号。
assert() 不仅能自动标识文件和出现问题的行号,还有一种无需更改代码就能开启或关闭 assert() 的机制。如果已经确认程序没有问题,就不需要再做断言,在 #include <assert.h> 语句的前面,定义一个宏 NDEBUG 即可。
#define NDEBUG
#include <assert.h>
此时重新编译程序,编译器就会禁用文件中所有的 assert() 语句。如果程序又出现问题,就可以移除 #define NDEBUG 指令(或者注释掉),再次编译时,就重新启用了 assert() 语句。
assert() 的缺点是,因为引入了额外的检查,增加了程序的运行时间。
一般我们在 debug 中使用,在 release 版本中选择禁用 assert 即可。
8 指针的使用
8.1 传址调用
例:写一个函数,交换两个整型变量的值。
错误代码:
#include <stdio.h>
void Swap1(int x, int y)
{
int tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
printf("交换前:a=%d b=%d\n", a, b);
Swap1(a, b);
printf("交换后:a=%d b=%d\n", a, b);
return 0;
}
输出结果:
可以发现其实没有产生交换的效果,我们调试一下来找找原因。
调试结果:
从调试结果可以发现, a 和 b 创建在 main 函数的内部,a 的地址是 0x005efbfc ,b 的地址是 0x005efbf0 ,在调用 Swap1 函数时,函数在内部创建了形参 x 和 y 接收 a 和 b 的值,但是 x 的地址是 0x005efb18 ,y 的地址是 0x005efb1c 。x 和 y 确实接收到了 a 和 b 的值,但是 x 、y 的地址和 a 、b的地址并不一样,相当于 x 和 y 是独立的空间,那么在 Swap1 函数内部交换 x 和 y 的值,自然不会影响 a 和 b ,所以当 Swap1 函数调用结束后回到 main 函数时,a 和 b 并没有交换。
Swap1 函数在使用的时候,是把变量的值传给了函数,这种调用函数的方式称为传值调用。
结论:实参传递给形参时,形参会单独创建一份临时空间来接收实参,对形参的修改不影响实参。
要想调用 Swap 函数内部操作的就是 main 函数中的 a 和 b ,就需要使用指针将 a 和 b 的地址传递给 Swap 函数。
正确代码:
#include <stdio.h>
void Swap2(int* px, int* py)
{
int tmp = 0;
tmp = *px;
*px = *py;
*py = tmp;
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
printf("交换前:a=%d b=%d\n", a, b);
Swap2(&a, &b);
printf("交换后:a=%d b=%d\n", a, b);
return 0;
}
输出结果:
可以看到用 Swap2 函数的形式就顺利完成了任务,这种将变量的地址传给函数的调用方式称为传址调用。
8.2 strlen和sizeof
8.2.1 strlen
strlen 是C语言的库函数,用来计算字符串的长度。其函数原型如下:
size_t strlen ( const char * str );
strlen 函数计算字符串长度的本质,是从 strlen 函数的参数 str 这个地址开始向后, \0 之前字符串中字符的个数。
由于 strlen 函数会一直向后找 \0 字符,直到找到为止,所以可能存在越界查找。
例:
#include <stdio.h>
int main()
{
char arr1[3] = { 'a', 'b', 'c' };
char arr2[] = "abc";
printf("%d\n", strlen(arr1));
printf("%d\n", strlen(arr2));
return 0;
}
输出结果:
8.2.2 sizeof
我们知道,sizeof 可以用来计算变量所占内存内存空间的大小,单位是字节。
如果操作数是类型,那么计算的是使用这个类型创建的变量所占内存空间的大小。
sizeof 只关注占用内存空间的大小,不在乎内存中存放什么数据。
例:
#include <stdio.h>
int main()
{
int a = 10;
printf("%d\n", sizeof(a));
printf("%d\n", sizeof a);
printf("%d\n", sizeof(int));
return 0;
}
输出结果:
注意,sizeof 在计算变量大小的时候,其实是根据类型来推算的,我们可以通过下面的例子来感受一下:
//输出结果是多少?
#include <stdio.h>
int main()
{
short s = 10;
int i = 2;
int n = sizeof(s = i + 4);
printf("%d\n", n);
printf("%d\n", s);
return 0;
}
输出结果:
根据大部分人的直觉,当代码执行到int n = sizeof(s = i + 4)
的时候,由于 s 是短整型,占2个字节,i 是整型,占4个字节, i + 4
的结果6也是,占4个字节,当把整型变量存放到短整型变量中时,会发生截断,s 仍为短整型,所以sizeof(s = i + 4)
计算的结果应该是2。
那么为什么结果是2、10而不是2、6呢?
这里就涉及到 sizeof 计算变量大小时的特点。由于 sizeof 是根据变量的类型来推算变量的大小,所以sizeof(s = i + 4)
中起决定性作用的变量是 s 。当 sizeof 的操作数是表达式的时候,表达式其实不会真实参与运算,也就是说在上面的例子中是不会让i + 4
后再赋给 s 的,所以 s 还保留原来的10。
那么为什么s = i + 4
不会计算呢?
我们写的代码,实际上是放在.c
的源文件中,而代码最终运行起来的时候实际上会生成一个.exe
的可执行程序。一个源文件变为可执行程序要经历编译和链接两个阶段,生成可执行程序后才会对代码中的运算进行操作。而 sizeof 确定操作数的类型是在编译这一个环节进行的,也就是说在上面的例子中s = i + 4
这个表达式在编译的环节就已经被换成了sizeof(short)
,所以当可执行程序执行到这一步的时候自然也就不会计算s = i + 4
这个表达式。
8.2.3 strlen和sizeof的对比
strlen
- strlen 是库函数,使用需要包含头文件 <string.h>。
- srtlen 用来计算字符串的长度,统计的是 \0 之前字符的个数。
- 关注内存中是否有 \0 ,如果没有 \0 ,就会持续往后找,导致可能会越界。
sizeof
- sizeof 是操作符。
- sizeof 用来计算操作数所占内存的大小,单位是字节。
- 不关注内存中存放什么数据。
8.2.4 strlen的模拟实现
要用指针来模拟实现 strlen 函数,我们可以用指针来接收传过来的数组,在计算的时候只要数组中的元素不是 “\0 ” 那么负责计数的变量就加一次,最后返回字符串的长度。
#include <stdio.h>
int my_strlen(char* str)
{
int count = 0;//负责计数
while (*str != '\0')
{
count++;
str++;
}
return count;
}
int main()
{
char arr[] = "abcdef";
int len = my_strlen(arr);
printf("%d\n", len);
return 0;
}
输出结果:
上述代码虽然能够完成任务,但是还不够好。有以下几个可以改进的地方:
- my_strlen 函数的意图是计算字符串的长度,并不希望 str 所指向的内容被修改,所以可以在 char* str 左边用 const 来修饰,让 str 所指向的内容不能被修改。
- while (*str != ‘\0’) 中,在没有判断 str 是否是空指针的情况下,就把 str 所指向的内容进行判断是比较危险的,为了确保指针的有效性,应在 while 前用 assert 进行判断一下。
- 由于字符串的长度不可能是负数,所以将 my_strlen 函数返回值的类型设置为 int 其实是不太合适的,而库函数中提供的 strlen 函数的返回值的类型为 size_t ,也就是 unsigned int,更合适一些。
改进代码:
#include <stdio.h>
#include <assert.h>
size_t my_strlen(const char* str)
{
size_t count = 0;
assert(str != NULL);
while (*str != '\0')
{
count++;
str++;
}
return count;
}
int main()
{
char arr[] = "abcdef";
int len = my_strlen(arr);
printf("%d\n", len);
return 0;
}
输出结果:
8.3 访问数组
8.3.1 数组名的理解
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int *p = &arr[0];
上述代码中,使用 &arr[0] 的方式拿到了数组第一个元素的地址,但是其实数组名本来就是地址,而且是数组首元素的地址。
例:
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("&arr[0] = %p\n", &arr[0]);
printf("arr = %p\n", arr);
return 0;
}
输出结果:
可以发现,数组名和数组首元素的地址打印出来的结果一模一样。
反例:
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("%d\n", sizeof(arr));
return 0;
}
输出结果:
如果数组名是数组首元素的地址,那输出结果应该是4或8才对。
结论:其实数组名就是数组首元素的地址,但是有2个例外:
- sizeof 中单独放数组名时,这里的数组名表示整个数组,计算的是整个数组的大小,单位是字节。
- &数组名 ,这里的数组名表示整个数组,取出的是整个数组的地址。
除此之外,任何地方使用数组名,都表示数组首元素的地址。
例:
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("&arr[0] = %p\n", &arr[0]);
printf("&arr[0]+1 = %p\n", &arr[0] + 1);
printf("arr = %p\n", arr);
printf("arr+1 = %p\n", arr + 1);
printf("&arr = %p\n", &arr);
printf("&arr+1 = %p\n", &arr + 1);
return 0;
}
输出结果:
可以发现,&arr[0] 和 &arr[0]+1 相差4个字节,arr 和 arr+1 相差4个字节,是因为 &arr[0] 和 arr 都是首元素的地址,+1 就是跳过一个元素。
而 arr 和 &arr 虽然打印出来的地址相同,但是 &arr 和 &arr+1 相差40个字节,正是因为 &arr 是整个数组的地址,+1 是跳过整个数组。
8.3.2 使用指针访问数组
由于数组中的元素在内存中是连续存放的,只要知道第一个元素的地址,顺藤摸瓜就能找到后面的所有元素。因此把 arr 首元素的地址给 p 后,p+i 就是 arr 中下标为 i 的元素的地址。
例:
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
int* p = arr;
//输入
for (i = 0; i < sz; i++)
{
scanf("%d", p + i);
//scanf("%d", arr+i);//也可以这样写
}
//输出
for (i = 0; i < sz; i++)
{
printf("%d ", *(p + i));
}
return 0;
}
输出结果:
既然数组名 arr 是数组首元素的地址,可以赋值给 p ,那么其实数组名 arr 和 p 在这里是等价,所以既然 arr[i] 可以访问数组的元素,那么 p[i] 也可以访问数组的元素。
例:
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
int* p = arr;
for (i = 0; i < sz; i++)
printf("%d ", *(p + i));
printf("\n");
for (i = 0; i < sz; i++)
printf("%d ", p[i]);
printf("\n");
for (i = 0; i < sz; i++)
printf("%d ", *(arr + i));
printf("\n");
for (i = 0; i < sz; i++)
printf("%d ", arr[i]);
printf("\n");
for (i = 0; i < sz; i++)
printf("%d ", i[arr]);
printf("\n");
return 0;
}
输出结果:
结论:
- p[i] == *(p+i).
- arr[i] == *(arr+i) == *(i+arr) == i[arr].
实际上,数组元素的访问在编译器中处理的时候,也是转换成首元素的地址+偏移量的形式来求出元素的地址,然后解引用来访问的。
8.3.3 一维数组传参的本质
例:
#include <stdio.h>
void test(int arr[])
{
int sz2 = sizeof(arr) / sizeof(arr[0]);
printf("sz2 = %d\n", sz2);
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int sz1 = sizeof(arr) / sizeof(arr[0]);
printf("sz1 = %d\n", sz1);
test(arr);
return 0;
}
输出结果:
上述代码中,我们想把数组传给一个函数后,在函数内部求出数组的元素个数。
但从输出结果来看,并没有得到想要的结果。
由于数组名是数组首元素的地址,那么在数组传参的时候,传递的是数组名,也就是说本质上数组传参传递的是数组首元素的地址。
所以函数形参的部分理论上应该使用指针变量来接收首元素的地址。而在函数内部写 sizeof(arr) 计算的是一个地址的大小而不是数组的大小吗,原因就在于函数的参数部分本质的是指针,所以在函数内部没有办法求得数组元素的个数。
例:
#include <stdio.h>
void test1(int arr[])//参数写成数组形式,本质上还是指针
{
printf("%d\n", sizeof(arr));
}
void test2(int* arr)//参数写成指针形式
{
printf("%d\n", sizeof(arr));//计算⼀个指针变量的⼤⼩
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
test1(arr);
test2(arr);
return 0;
}
输出结果:
结论:一维数组传参,形参的部分可以写成数组的形式,也可以写成指针形式。
8.4 应用:冒泡排序
冒泡排序的核心思想:两两相邻的元素进行比较。
#include <stdio.h>
//方法一
void bubble_sort1(int arr[], int sz)//参数接收数组元素个数
{
int i = 0;
for (i = 0; i < sz - 1; i++)// 确定排序的趟数
{
int j = 0;
for (j = 0; j < sz - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
}
//方法二
void bubble_sort2(int arr[], int sz)//参数接收数组元素个数
{
int i = 0;
for (i = 0; i < sz - 1; i++)
{
int flag = 1;//假设这⼀趟已经有序了
int j = 0;
for (j = 0; j < sz - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
flag = 0;//发⽣交换就说明,⽆序
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
if (flag == 1)//这⼀趟没交换就说明已经有序,后续⽆序排序了
break;
}
}
void print(int* arr, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
int main()
{
int arr1[] = { 3,1,7,5,8,9,0,2,4,6 };
int arr2[] = { 3,1,7,5,8,9,0,2,4,6 };
int sz1 = sizeof(arr1) / sizeof(arr1[0]);
int sz2 = sizeof(arr2) / sizeof(arr2[0]);
bubble_sort1(arr1, sz1);
bubble_sort2(arr2, sz2);
print(arr1, sz1);
printf("\n");
print(arr2, sz2);
return 0;
}
输出结果: