十三、指针（二）

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 = &num;
	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

1. strlen 是库函数，使用需要包含头文件 <string.h>。
2. srtlen 用来计算字符串的长度，统计的是 \0 之前字符的个数。
3. 关注内存中是否有 \0 ，如果没有 \0 ，就会持续往后找，导致可能会越界。

sizeof

1. sizeof 是操作符。
2. sizeof 用来计算操作数所占内存的大小，单位是字节。
3. 不关注内存中存放什么数据。

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;
}

输出结果：

上述代码虽然能够完成任务，但是还不够好。有以下几个可以改进的地方：

1. my_strlen 函数的意图是计算字符串的长度，并不希望 str 所指向的内容被修改，所以可以在 char* str 左边用 const 来修饰，让 str 所指向的内容不能被修改。
2. while (*str != ‘\0’) 中，在没有判断 str 是否是空指针的情况下，就把 str 所指向的内容进行判断是比较危险的，为了确保指针的有效性，应在 while 前用 assert 进行判断一下。
3. 由于字符串的长度不可能是负数，所以将 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个例外：

1. sizeof 中单独放数组名时，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。
2. &数组名 ，这里的数组名表示整个数组，取出的是整个数组的地址。

除此之外，任何地方使用数组名，都表示数组首元素的地址。

例：

#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;
}

输出结果：

结论：

1. p[i] == *(p+i).
2. 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;
}

输出结果：