重生之霸道C语言爱上我之走入指针（2）

接上文，今天我们继续来探讨指针的基础。

1.指针运算

指针的基本运算有三种，分别是：

1.指针+-整数

2.指针-指针

3.指针的关系运算

1.1 指针+-整数

在数组中，各个元素的位置是连续存放的，所以只要知道一个元素的地址，顺藤摸瓜就可以知道所有元素的地址。

int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

如果得到了arr[0]的地址，并把它存在指针变量p里，那么p+1就是arr[1]的地址，p+2就是arr[2]的地址，p+3就是arr[3]的地址，以此类推，p+i就是arr[i]的地址。如果对这些地址进行解引用，即*(p+i)就是元素arr[i]的值，这样子分析，就可以通过取地址的方法对数组元素进行打印。

//用指针正着打印数组
int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int* p = &arr[0];
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));//p+i这里就是指针+整数
        //或者printf(%d ", *p);
        //p++;
	}
	return 0;
}

//用指针倒着打印数组
int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int* p = &arr[0];
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = sz - 1; i >= 0; i--)
	{
		printf("%d ", *(p + i));
	}
}

该过程没有用访问数组下标的方式，而是用p+i得到下标为i的数组元素。只要想访问某个地址后面的地址，用指针都可以。

1.2 指针-指针

根据前面的知识可以知道，指针-指针其实就是地址-地址，指针-指针的绝对值得到的就是指针与指针之间元素的个数。

int main()
{
	int arr[10] = { 0 };
	printf("%d", &arr[6] - &arr[0]);
	return 0;
}

所以上述代码的结果就是6。（就等于两个数组元素下标的相减）

但是这种运算的前提是两个指针指向的是同一个空间。

int main()
{
	char ch[10];
	int arr[5];
	printf("%d", &ch[9] - &arr[1]);
	return 0;
}

上面就是错误示范！！！

那我们可以用这个指针-指针来做什么呢？

这里有一个计求字符串长度的例子。

#include<string.h>
#include<stdio.h>
int main()
{
	char arr[] = "abcdef";
	size_t len = strlen(arr);
	printf("%zd", len);

	return 0;
}

 这是正常运用strlen函数来计算的结果。这里注意运用strlen的时候，函数的返回类型是size_t类型，并且需要包含string.h这个头文件，而且strlen计算的是字符串中\0之前的字符个数。

我们自己来写一个求字符串长度的函数：

size_t my_strlen(char* s)
{
	int count = 0;
	//我们知道，字符串的结束标志是\0
	while (*s != '\0')//当这个地址的元素不是\0时，就证明字符串的长度计算还没有计算完成
	{
		count++;//既然没有完成，就继续加1
		s++;//然后继续判断下一位位置的元素是不是\0
	}
	return count;
}
int main()
{
	char arr[] = "abcdef";
	//要注意数组名就是数组首元素的地址
	size_t len = my_strlen(arr);//arr = &arr[0]
	printf("%zd", len);
	return 0;
}

 这是通过一步一步的计数得到的字符串长度，那如何用指针-指针的方式来求字符串长度呢？

那我们一定要再次抓住这个特点：指针-指针的绝对值得到的就是指针与指针之间元素的个数。

size_t my_strlen(char* s)
{
	char* start = s;//将数组首元素的指针用start变量备份一份
	//我们知道，字符串的结束标志是\0
	while (*s != '\0')//判断这个地址的元素是不是\0
	{
		s++;//如果不是，继续判断下一位位置的元素是不是\0
	}
	return s - start ;//如果是，保留当前指针s，s与start相减，得到二者之间元素个数
}
int main()
{
	char arr[] = "abcdef";
	//要注意数组名就是数组首元素的地址
	size_t len = my_strlen(arr);//arr = &arr[0]
	printf("%zd", len);
	return 0;
}

 1.3 指针的关系运算

我们要清楚，随着数组元素下标的由低到高地增长，其地址是由低到高地变化的。

//指针的关系运算
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int sz = sizeof(arr) / sizeof(arr[0]);
	while (p < arr + sz)//这就是指针的关系运算，p为首元素的地址，arr也为首元素的地址
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

 上面的代码就是使用指针的关系运算来打印数组。

2.野指针

概念：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）。

2.1 野指针成因

2.1.1 指针未初始化

//指针未初始化情景下的野指针
int main()
{
	int* p;//局部变量指针未初始化，默认为随机值
	*p = 20;//非法访问，p就是野指针
	printf("%d", *p);//打印不出来
	return 0;
}

2.1.2 指针越界访问

//指针越界访问情景下的野指针
int main()
{
	int arr[10] = { 0 };
	int* p = &arr[0];
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < 11; i++)
	{
		//当指针指向的范围超过数组arr的范围时，p就是野指针
		*(p++) = i;//这行代码的意思是*p = i；p++；
	}
	return 0;
}

2.1.3 指针指向的空间释放

//指针指向的空间释放情景下的野指针
int* test()
{
	int n = 100;//注意，这是一个局部变量，出了这个test()函数，变量n就被销毁了
	return &n;
}
int main()
{
	int* p = test();
	//p为野指针，因为n为局部变量，范围的&n是当时局部变量n还在的时候n的地址的数据
	// 现在还能找到这个位置，但是已经不能再用了，因为当时创建n变量所申请的空间已经被销毁了
	printf("%d", *p);
	return 0;
}

2.2 如何规避野指针

根据野指针的成因，针对性地回避。

2.2.1 指针初始化

如果明确知道指针指向哪里就直接赋值地址，如果不知道指针应该指向哪里，可以给指针赋值NULL。

NULL是C语言中定义的一个标识符常量，值是0，0也是地址，但是这个地址是无法使用的，读写该地址的时候会报错。

初始化如下：

//通过设NULL空指针来规避野指针
int main()
{
	int n = 10;
	int* p1 = &n;
	int* p2 = NULL;//这里的NULL就是空指针

	return 0;
}

2.2.2 小心指针越界

一个程序向内存申请了哪些空间，通过指针也就只访问哪些空间，不能超出范围访问，超过了就是越界访问。

2.2.3 指针不再使用时，及时置NULL，指针使用之前检查有效性

当指针变量指向⼀块区域的时候，我们可以通过指针访问该区域，后期不再使⽤这个指针访问空间的 时候，我们可以把该指针置为NULL。因为约定俗成的⼀个规则就是：只要是NULL指针就不去访问， 同时使⽤指针之前可以判断指针是否为NULL。

我们可以把野指针想象成野狗，野狗放任不管是⾮常危险的，所以我们可以找⼀棵树把野狗拴起来， 就相对安全了，给指针变量及时赋值为NULL，其实就类似把野狗栓起来，就是把野指针暂时管理起来。

不过野狗即使拴起来我们也要绕着⾛，不能去挑逗野狗，有点危险；对于指针也是，在使⽤之前，我 们也要判断是否为NULL，看看是不是被拴起来起来的野狗，如果是不能直接使⽤，如果不是我们再去使⽤。

//指针不再使用时，及时置NULL, 指针使用之前检查有效性
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
		p++;
	}
	//注意，*p = i过后紧接着就是p++，所以当i加到9的时候循环完成后指针变成了p+10
	//此时p已经越界了，可以把p置为NULL
	p = NULL;
	//下次使用的时候，判断p不为NULL的时候再使用
	//......
	int b = 20;
	p = &b;//重新让p获得地址
	if (p != NULL)
	{
		*p = 200;
		printf("%d", *p);
	}
	return 0;
}

上面代码的结果是200。

2.2.4 避免返回局部变量的地址

如2.1.3的例子，不要返回局部变量的地址。

3.assert断言

assert.h 头⽂件定义了宏 assert() ，⽤于在运⾏时确保程序符合指定条件，如果不符合，就报错终止运行。这个宏常常被称为“断言”。

例如：

上面的代码在程序运行到这一行语句的时候，验证p变量是否等于NULL，如果括号里面的表达式为真，则什么都不会发生，如果括号里面的表达式为假，就会报错。

assert()宏接受一个表达式为参数。如果该表达式为真（即返回值为非零），他将不会产生任何作用，程序继续运行；如果表达式为假（即返回值为零），assert()就会报错。在报错信息中，会显示一条错误信息，显示没有通过的表达式，以及包含这个表达式的文件名和行号。

assert()的使用对程序员来说非常友好，它不仅能自动标识文件和出问题的行号，还有一种无需更改代码就能开启或关闭assert()的机制。如果已经确认程序没有问题，不需要再做断言，就在#include<assert.h>语句的前面，定义一个宏NDEBUG。

#define NDEBUG
#include<assert.h>

然后重新编译程序，编译器就会禁用所有的assert语句。如果程序又出现了问题，移除#define NDEBUG后就可以重新启用assert语句。

assert()的缺点是，因为引入了额外的调查，增加了程序的运行时间。

一般是在Debug中使用。

4.指针的使用和传址使用

4.1 strlen的模拟实现

库函数strlen的功能是求字符串的长度，统计的是字符串中\0之前的字符个数。

函数的原型如下：

size_t strlen ( const char* str);//*str不能变，即str的内容不能变

参数str接受的是一个字符串的起始地址，然后开始统计字符串中\0之前的字符个数，最终返回长度。

如果要模拟实现，只需要从起始地址开始向后逐个字符遍历，只要不是\0字符，计数器就+1，这样直到\0就停止。

参考代码如下：

size_t my_strlen(const char* s)//my_strlen是求字符串长度的，是不希望s指的字符串被修改的
{
	int count = 0;
	assert(s);//判断s是否为空指针
	while (*s)//如果为\0，ASCII码值为0，while循环终止
	{
		count++;
		s++;
	}
	return count;
}
int main()
{
	//若my_strlen的参数直接就是一串字符串，那就直接确定了*s不会变
	size_t len = my_strlen("abcdef");//相当于传了首字符的地址
	printf("%zd", len);
	return 0;
}

在这里补充一下几个0的区别：

0 —— 数字0

' \0 ' —— 转义字符 ——ASCII码值为0

NULL —— 空指针 —— ASCII码值为0

' 0 ' —— 字符0 —— ASCII码值为48

4.2 传值调用和传值调用

什么问题，非指针解决不可呢？

例如：

1.写一个函数，交换两个整型变量的值

我们可以会这样子写：

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

 但是运行起来我们发现，他并没有产生什么效果

这是为什么呢？

那让我们进行调试一下

我们发现在main函数内部，创建了a和b，a的地址是0x00b2f8c0，b的地址是0x00b2f8b4，在调⽤ Swap1函数时，将a和b传递给了Swap1函数，在Swap1函数内部创建了形参x和y接收a和b的值，但是 x的地址是0x00b2f7dc，y的地址是0x00b2f7e0，x和y确实接收到了a和b的值，不过x的地址和a的地址不 ⼀样，y的地址和b的地址不⼀样，相当于x和y是独立的空间，那么在Swap1函数内部交换x和y的值， 自然不会影响a和b，当Swap1函数调用结束后回到main函数，a和b的没法交换。即a和b只是把值传上去了，并没有改变a和b本身，这种叫传值调用。

结论：实参传递给形参的时候，形参会单独创建一份临时空间来接受实参，对形参的修改不影响实参。

所以Swap1失败了。

那怎么办呢？

现在要解决的就是当调用Swap函数的时候，Swap函数内部操作的就是main函数中的a和b，直接就把a和b的值给交换了。那么就得使用指针了，将a和b的地址传给Swap函数，Swap函数用指针变量来接受就好了。

参考代码如下：

void Swap(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);
	Swap(&a, &b);
	printf("交换后a = %d, b = %d\n", a, b);

	return 0;
}

 这时候运行结果就是正确的了：

这样子我们就顺利地完成了任务，这里调用Swap函数的时候是将变量的地址传递给了函数，这种函数调用方式叫做：传址调用。

传值调用，可以让函数和主调函数之间建立真正的联系，在函数内部可以修改主调函数中的变量；所以以后的计算当中，如果只需要主调函数变量的值，那就运用传值调用，如果是需要改变主调函数中变量的值，那就运用传址调用。

谢谢大家的捧场~~~