956237586 – 第 20 页 – HYL Studio

2015.11.6.KMP算法

KMP算法是要解决的问题是一个字符串中查找指定子串的问题。由于臻臻问我这个问题，所以我不得不再次看看KMP -_-|| ，同时感谢袁涛和王宇晖Orz，（另：默默等待王霸的KMP第三层优化，但愿他能成功）。

本人水平不高，有写错的地方还请批评指正。

先说传统的匹配算法。以图中的字符串为例，第一行是要匹配的目标字符串（称之为主串。其中第i个简写为S[i])，要匹配的字符串称之为子串（也叫模式串，其中第i个简写为P[i]）接下来每行代表一次匹配操作，黄色部分代表匹配成功的部分，红色字符为发现的第一个不匹配的字符。所有字符计数从1开始。所有字符计数从1开始。所有字符计数从1开始。（重要的事情说三遍）

左侧第一列是每一次匹配情况。下面是详细的匹配过程描述。为了方便观察变化，上图中每次移动子串将在新行展现。实际匹配时只在当前行向后移动。

1. 将P[1]和S[1]对齐。

2. 比较S[1]与P[1]是否相同（结果是不相同）。图中第1行

3. 将P[1]和S[2]对齐（把模式串向后移动1个字符的位置）。

4. 比较P[1]与S[2]是否相同（结果是相同）。

5. 比较P[2]与S[3]是否相同（结果是相同）。

6. 比较P[3]与S[4]是否相同（结果是相同）。

7. 比较P[4]与S[5]是否相同（结果是不相同）。图中第2行

8. 将P[1]和S[3]对齐（把模式串向后移动1个字符的位置）。

9. 比较P[1]与S[3]是否相同（结果是不相同）。图中第3行

10. 将P[1]和S[4]对齐（把模式串向后移动1个字符的位置）。

11. 比较P[1]与S[4]是否相同（结果是不相同）。图中第4行

12. 将P[1]和S[5]对齐（把模式串向后移动1个字符的位置）。

13. 比较P[1]与S[5]是否相同（结果是不相同）。图中第5行

14. 将P[1]和S[6]对齐（把模式串向后移动1个字符的位置）。

15. 比较P[1]与S[6]是否相同（结果是相同）。

16. 比较P[2]与S[7]是否相同（结果是相同）。

17. 比较P[3]与S[8]是否相同（结果是相同）。

18. 比较P[4]与S[9]是否相同（结果是相同）。

19. 比较P[5]与S[10]是否相同（结果是相同）。

20. 比较P[6]与S[11]是否相同（结果是相同）。

21. 比较P[7]与S[12]是否相同（结果是相同）。

22. 比较P[8]与S[13]是否相同（结果是不相同）。图中第6行

23. 将P[1]和S[7]对齐（把模式串向后移动1个字符的位置）。

24. 比较P[1]与S[7]是否相同（结果是不相同）。图中第7行

25. 将P[1]和S[8]对齐（把模式串向后移动1个字符的位置）。

26. 比较P[1]与S[8]是否相同（结果是不相同）。图中第8行

27. 将P[1]和S[9]对齐（把模式串向后移动1个字符的位置）。

28. 比较P[1]与S[9]是否相同（结果是相同）。

29. 比较P[2]与S[10]是否相同（结果是相同）。

30. 比较P[3]与S[11]是否相同（结果是相同）。

31. 比较P[4]与S[12]是否相同（结果是相同）。

32. 比较P[5]与S[13]是否相同（结果是不相同）。图中第9行

33. 将P[1]和S[10]对齐（把模式串向后移动1个字符的位置）。

34. 比较P[1]与S[10]是否相同（结果是不相同）。图中第10行

35. 将P[1]和S[11]对齐（把模式串向后移动1个字符的位置）。

36. 比较P[1]与S[11]是否相同（结果是不相同）。图中第11行

37. 将P[1]和S[12]对齐（把模式串向后移动1个字符的位置）。

38. 比较P[1]与S[12]是否相同（结果是相同）。

39. 比较P[2]与S[13]是否相同（结果是不相同）。图中第12行

40. 将P[1]和S[13]对齐（把模式串向后移动1个字符的位置）。

41. 比较P[1]与S[13]是否相同（结果是相同）。

42. 比较P[2]与S[14]是否相同（结果是相同）。

43. 比较P[3]与S[15]是否相同（结果是相同）。

44. 比较P[4]与S[16]是否相同（结果是相同）。

45. 比较P[5]与S[17]是否相同（结果是相同）

46. 比较P[6]与S[18]是否相同（结果是相同）

47. 比较P[7]与S[19]是否相同（结果是相同）

48. 比较P[8]与S[20]是否相同（结果是不相同）图中第13行

49. 将P[1]和S[14]对齐（把模式串向后移动1个字符的位置）。

50. 比较P[1]与S[14]是否相同（结果是不相同）。图中第14行

51. 将P[1]和S[15]对齐（把模式串向后移动1个字符的位置）。

52. 比较P[1]与S[15]是否相同（结果是不相同）。图中第15行

53. 将P[1]和S[16]对齐（把模式串向后移动1个字符的位置）。

54. 比较P[1]与S[16]是否相同（结果是相同）。

55. 比较P[2]与S[17]是否相同（结果是相同）。

56. 比较P[3]与S[18]是否相同（结果是相同）。

57. 比较P[4]与S[19]是否相同（结果是相同）。

58. 比较P[5]与S[20]是否相同（结果是相同）

59. 比较P[6]与S[21]是否相同（结果是相同）

60. 比较P[7]与S[22]是否相同（结果是相同）

61. 比较P[8]与S[23]是否相同（结果是相同）

62. 比较P[9]与S[24]是否相同（结果是相同）

63. 比较P[10]与S[25]是否相同（结果是相同）

64. 匹配成功。图中第16行

仔细观察原始匹配算法的规律，以上述第15步开始为例。

当模式串的前7个字符P[1 2 3 4 5 6 7]与主串S中的某个子部S[6 7 8 9 10 11 12]相匹配时，如果P[8]（图中红色的c）与S[13]（a）匹配失败，下一次将会把P[1]与S[7]对齐，然后从P[1]与S[7]开始向后逐一进行匹配。

也就是说：

当模式串的前i个字符P[1 – i]与主串S中的某个子部S[m ···· m + (i – 1)]相匹配时，如果P[i + 1]（图中红色的c）与S[m + i]（a）匹配失败，下一次将会把P[1]与S[m + 1]对齐，然后从P[1]与S[m + 1]开始向后逐一进行匹配。

至此原始的字符串匹配算法结束。

我们最开始的目的是找到主串S中是否存在子串P，也就是说我们希望尽可能多的匹配子串P的内容。观察图中第6-9行的过程（对应上文步骤14开始的过程）。

当P[8]（图中红色的c）与S[13]（a）匹配失败，会有两次后移子串的操作，这时会发现在第9行中子串P的前4个字符组成的字符串和第6行中前7个字符组成的子串的后4个字符组成的字符串是一样的。也就是图中蓝色框线部分。放到一起来看是这样的：

换句话说，也就是子串前7个字符组成的字符串的头部和尾部有4个字符匹配（下文称之为前缀和后缀）。

这时观察上面的图，那么可以思考一个改进方案，就是当发现P[8]与S[13]不匹配的时候，下一步直接比较P[5]和S[13]（因为前4个已经在图中第6行匹配过了），也就是把子串S移动了3个字符的距离。

在这里我们引入跳转表如下（先不要管怎么算的）。

含义是：当P[j]与主串中某个字符（设为t，在上例中是S[13]）不匹配时，从P[next[j]]（P[5]）开始继续与主串中的t（S[13]）比较（也就是把子串后移j – next[j]个字符的距离），例如上例中的next[8] = 5，含义就是当P[8]与t（S[13]）匹配不成功时，直接从P[5]开始继续与主串中的t（S[13]）比较（也就是把子串后移8-5个字符的距离）。

可以发现，next的数值是和主串无关的，只和这个子串本身有关。那么这样，最原始的匹配步骤就可以变成下面图中的样子。也就是每次尽可能多的匹配子串与主串，不要每次都移动一个进行尝试。

那么问题来了（不是蓝翔），怎么计算next[j]？

根据前面的例子可以看出，next[j]的值就是P[1 ····· j – 1]中可以找到的最长且相等的前缀与后缀的长度再加1（规定第1个值为0，因为如果第一个字母都不匹配的话就要向后移动1个字符的长度，1 = j – next[j] = 1 – 0），比如前面例子中子串前7个字符中可以找到最长且相等的前缀和后缀就是abca，长度是4，所以next[8]的值就是4 + 1 = 5。按照这个原则，就可以构造出上面的跳转表了。

上面的方法是人眼非常方便的做法，但是如果要写程序则会变得非常复杂。并且当字符串变长或者字的数量变多的时候直接查找会变的非常低效。所以需要考虑程序怎么方便快速的实现，在这种时候通常的思路是充分利用之前的结果。

例如想求next[5]，假设next[4]以及以前的next值都已经计算完毕如图。

想求next[5]，也就是模式串前4个字符中能找到最长的一对前后缀长度+1，这时我们已知next[4] = 1也就是说模式串前3个字符找不到一对前后缀相等，我们尝试考虑加上第4个字符P[4]看看能不能找到，既然已经知道前3个中找不到一对相等的前后缀，那么只需要判断要加入的字符P[4]和P[1]是不是相同，如果相同，那么代表加入P[4]后最长前后缀的长度可以增加1，也就是next[5] = next[4] + 1 = 1 + 1 = 2

另外一个例子

想求next[8]，假设next[7]以及之前的值已知如图。

想求next[8]，也就是模式串前7个字符中能找到最长的一对前后缀长度+1，这时我们已知next[7] = 4也就是说模式串前6个字符找到最长且相等的一对前后缀长度为3（图中红色和蓝色部分），我们尝试考虑加上第7个字符P[7]看看能不能延长最长前后缀的长度，既然已经知道前6个中找到最且相等的一对前后缀长度为3，那么只需要判断要加入的字符P[7]与P[4]是不是相同（红框后的红圈字符和篮框后的红圈字符），如果相同，那么代表加入P[7]后最长前后缀的长度可以增加1，也就是可以延长也就是next[8] = next[7] + 1 = 4 + 1 = 5

分析上面的过程，其实就是尝试尽可能添加进更多的字符进入已经找到的最长且相等的前后缀中，第一个字符的next值一定是0，从第二个开始使用上面的规律，如果最后一个字符的加入可以延长最长前后缀，那么就加进去，如果之前已经没有最长的前后缀，那么直接写1。

再找一个特殊情况如下（为了说明另一种情况我换了个字符串）。想求next[5]

想求next[5]，也就是模式串前4个字符中能找到最长的一对前后缀长度+1，这时我们已知next[4] = 2也就是说模式串前3个字符找到最长且相等的一对前后缀长度为1（图中红色和蓝色部分），我们尝试考虑加上第4个字符P[4]看看能不能延长最长前后缀的长度，既然已经知道前3个中找到最且相等的一对前后缀长度为1，那么只需要判断要加入的字符P[4]与P[2]是不是相同（红框后的红圈字符和篮框后的红圈字符），如果相同，那么代表加入P[4]后最长前后缀的长度可以增加1，但是显然P[4]与P[2]不等，加入后无法延长目前最长前后缀的长度。这时候却不能结束，因为你明显能看到前4个字符最长的前后缀长度明明是1，所以要继续尝试将P[4]与P[1]比较，如果相同，那么说明最长前后缀长度可以从0增加到1，所以next[5] = next[2] + 1 = 1 + 1 = 2

说了这么多，求next[j]方法推导总结如下：

next[1] = 0 (j = 1时)

假设next[j] = k，求next[j + 1]。

因next[j] = k (由假设)，所以有：

P[1 ···· (k – 1)] = P[( j – (k – 1)) ···· (j – 2) (j – 1)] (由定义)

分两种情况讨论：

若P[k]=P[j]，则有P[1 ···· (k-1) k] = P[ (j – (k – 1)) (j – (k – 2)) ···· (j -1) j ]，且不存在k’ > k 满足等式

（图中取j = 7的情况）

所以，next[j + 1] = k + 1=next[j] + 1

若P[k] ≠ P[j]( k < j )，则将求next函数值的问题看成一个模式匹配问题，整个模式串既是主串又是模式串。（图中取j=8的情况）

继续设已知next[k] = k’（也就是图中的next[5] = 2）

分两种情况讨论：

若P[k’] = P[j]，则有P[1 2 ···· (k’ – 1) k’] = P[(j – (k’ – 1)) (j – (k’ – 2)) ···· (j – 1) j ] (1 < k’ < k < j )

那么next[j + 1] = k’ + 1 = next[k] + 1

若P[k’] ≠ P[j] ( k < j )，则又将求next函数值的问题看成一个模式匹配问题，整个模式串既是主串又是模式串

重复以上讨论：直至P[j]和模式串中某个字符匹配成功，即找到某个k’’使next[j + 1]=k’’ + 1=next[k’] + 1

反之不存在任何k*(1 < k* < j)，则next[j + 1] = 1。

到此为止，搜索的过程就可以优化成上图的样子了。但是还没完，仔细看，第2次匹配，当发现P[4]（a）与S[5]（b）匹配失败时，下一次匹配按照跳转表应该是P[1]继续和S[5]匹配，但是可以发现P[4]和P[1]是一样的，那么进行两次匹配是没必要的，所以我们就可以再进行一次优化。第9行的情况也同理。

可以简化成下图这样。对应跳转表也在下面。

在第一次的跳转表的基础上，如果发现要跳转的字符和自身相等，那么可以把自身的next值改为要跳转字符的next值，否则保持不变，计算过程中依然充分利用已知的nextval值。举几个例子：

·······

上图中的next[2] = 1，而P[2] ≠ P[1]，所以nextval[2] = next[2] = 1。

·······

上图中的next[4] = 1，而P[4] = P[1]，所以nextval[4] = nextval[1] = 0。

上图中的next[6] = 3，而P[6] = P[3]，所以nextval[6] = nextval[3] = 1。

上图中的next[10] = 2，而P[10] = P[2]，所以nextval[10] = nextval[2] = 1。

经过这两次优化，可以发现，原本需要匹配16次的事情现在只需要匹配6次即可完成。是不是非常神奇？

C基础系列教程11——常见错误总结

该系列文章内容可能来源我本人或者zhrmoe（他的主页：https://zhr.moe）的编写。文章如果有错误欢迎批评指正，谢谢！转载请注明来自本站，另外，本系列教程中的代码建议初学者自己手打一遍，不要直接复制（由于某些奇怪的原因可能会导致你复制的代码出现错误！相信自己的双手吧=-=
在这里总结一些初学者常见错误，建议在考试前看一遍。


//从头写起吧，在最开始的预处理语句。
//———————————————————————–
//正确形式：
#include<stdio.h>
#include"stdio.h"
#include<math.h>
#include<math.h>
//错误形式：
//1.拼写错误
#includ<stdio.h>
include<studio.h>
//2.忘记加入要使用的头文件。比如math.h或者string.h
//注意：之后代码之前都没有写头文件
//———————————————————————–
//正确形式：
int main() {
	return 0;
}
//错误形式：
//1.拼写错误
int mian() {
	retrun 0;
}
//2.缺少必要的空格或分号
intmian() {
	retrun 0;
}
//3.括号不成对出现(一个单独的括号会很伤心的~)
int mian() {
	retrun 0;
	//———————————————————————- –
	//正确形式：
	int a, b, c;
	int a = 0, b = 0, c = 0;
	int a[50];
	int a[50] = { 0 };
	double t;
	double t = 0;
	char c = 'a';
	char *s = "abcdefg";
	//错误形式：
	//1.符号使用错误，编写过程不易察觉。。
	int a; b; c;
	int a = 0; b = 0, c = 0;
	char c = "a";
	char *s = 'abcdefg';
	//2.定义数组使用变量
	int i = 50;
	int a[i];
	//———————————————————————- –
	//正确形式：
	int main() {
		int *a = NULL;
		int b = 0;
		a = &b;
		return 0;
	}
	//错误形式：
	//1.星号使用错误，切记指针的定义和调用之间的不同
	int main() {
		int *a;
		int b = 0;
		*a = &b;
		return 0;
	}
	//2.野指针的初始化, NULL必须大写
	int main() {
		int *a = null;
		return 0;
	}
	//———————————————————————- –
	//正确形式：
	int main() {
		int a = 1;
		double b = 2.1;
		char c = 'a';
		char *s = "abcdefg";
		int *p = NULL;
		p = &a;
		printf("%d", a);
		printf("%d", *p);
		printf("%.2f", b);
		printf("%c", c);
		printf("%c", *s);
		printf("%s", s);
		printf("%p", p);
		scanf("%d", &a);
		scanf("%lf", &b);
		scanf("%c", &c);
		scanf("%s", s);
		return 0;
	}
	//错误形式：
	//1.格式化文本中的类型与变量类型或数量对应错误
	//可以通过编译，但结果可能与预期结果不一致
	int main() {
		int a = 1;
		double b = 2.1;
		char c = 'a';
		char *s = "abcdefg";
		int *p = NULL;
		p = &a;
		printf("%c", a);
		printf("%*.*f", 3, b);
		scanf("%lf", &a);
		return 0;
	}
	//2.scanf不加或多加取址符&
	int main() {
		int a = 1;
		int *p = NULL;
		p = &a;
		scanf("%d", a);
		scanf("%d", &p);
		return 0;
	}
	//———————————————————————- –
	//正确形式：
	int main() {
		int a, b, c;
		scanf("%d %d %d", &a, &b, &c);
		if (a == b) {
			//do something
		} else if (b <= c) {
			//do something
		} else if (c >= a && c <= b) {
			//do something
		} else {
			//do something
		}
		return 0;
	}
	//错误形式：
	//1.逻辑运算符号错误, 引起程序逻辑分支出现问题，得不到正确结果
	int main() {
		int a, b, c;
		scanf("%d %d %d", &a, &b, &c);
		if (a = b) {
			//do something
		} else if (b <= c) {
			//do something
		} else if (a <= c <= b) {//注意！这种写法是错的！！
								 //do something
		} else {
			//do something
		}
		return 0;
	}
	//2.if else 级联写法错误，导致编译失败或者程序逻辑错误
	//可能出现多余大括号，多余分号。缺少空格，或缺少分号
	int main() {
		int a, b, c;
		scanf("%d %d %d", &a, &b, &c);
		if (a == b) {
			//do something
		}elseif(b <= c) {
			//do something
		} else if (c >= a && c <= b);
		{
			//do something
		} else {
			//do something
		};
		return 0;
	}
	//———————————————————————- –
	//正确形式：
	int add(int x, int y);
	int padd(int *x, int *y);
	int main() {
		int a = 1, b = 2;
		int *pa, *pb;
		pa = &a;
		pb = &b;
		printf("%d\n", add(a, b));
		printf("%d\n", padd(&a, &b));
		printf("%d\n", padd(pa, pb));
		return 0;
	}
	int add(int x, int y) {
		return x + y;
	}
	int padd(int *x, int *y) {
		return *x + *y;
	}
	//错误形式：
	//1.参数传递类型错误。
	int add(int x, int y);
	int padd(int *x, int *y);
	int main() {
		int a = 1, b = 2;
		int *pa, *pb;
		pa = &a;
		pb = &b;
		printf("%d\n", add(&a, &b));
		printf("%d\n", padd(a, b));
		printf("%d\n", padd(&pa, &pb));
		return 0;
	}
	int add(int x, int y) {
		return x + y;
	}
	int padd(int *x, int *y) {
		return *x + *y;
	}
	//2.声明形式和实际形式不符
	void add(int *x, int y);
	double padd(int *x, int *y);
	int main() {
		int a = 1, b = 2;
		int *pa, *pb;
		pa = &a;
		pb = &b;
		printf("%d\n", add(a, b));
		printf("%d\n", padd(&a, &b));
		printf("%d\n", padd(pa, pb));
		return 0;
	}
	float add(int x, int y) {
		return x + y;
	}
	void padd(int *x, int *y) {
		return *x + *y;
	}
	//———————————————————————-
	//通过考试不是目的，提高自己的程序编写能力才是重要的~
	//如果你看到了这里，感谢你的耐心！
	//记的，细节决定成败。。

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

//从头写起吧，在最开始的预处理语句。

//———————————————————————–

//正确形式：

#include<stdio.h>

#include"stdio.h"

#include<math.h>

//错误形式：

//1.拼写错误

#includ<stdio.h>

include<studio.h>

//2.忘记加入要使用的头文件。比如math.h或者string.h

//注意：之后代码之前都没有写头文件

//———————————————————————–

//正确形式：

int main() {

return 0;

}

//错误形式：

//1.拼写错误

int mian() {

retrun 0;

}

//2.缺少必要的空格或分号

intmian() {

retrun 0;

}

//3.括号不成对出现(一个单独的括号会很伤心的~)

int mian() {

retrun 0;

//———————————————————————- –

//正确形式：

int a, b, c;

int a = 0, b = 0, c = 0;

int a[50];

int a[50] = { 0 };

double t;

double t = 0;

char c = 'a';

char *s = "abcdefg";

//错误形式：

//1.符号使用错误，编写过程不易察觉。。

int a; b; c;

int a = 0; b = 0, c = 0;

char c = "a";

char *s = 'abcdefg';

//2.定义数组使用变量

int i = 50;

int a[i];

//———————————————————————- –

//正确形式：

int main() {

int *a = NULL;

int b = 0;

a = &b;

return 0;

}

//错误形式：

//1.星号使用错误，切记指针的定义和调用之间的不同

int main() {

int *a;

int b = 0;

*a = &b;

return 0;

}

//2.野指针的初始化, NULL必须大写

int main() {

int *a = null;

return 0;

}

//———————————————————————- –

//正确形式：

int main() {

int a = 1;

double b = 2.1;

char c = 'a';

char *s = "abcdefg";

int *p = NULL;

p = &a;

printf("%d", a);

printf("%d", *p);

printf("%.2f", b);

printf("%c", c);

printf("%c", *s);

printf("%s", s);

printf("%p", p);

scanf("%d", &a);

scanf("%lf", &b);

scanf("%c", &c);

scanf("%s", s);

return 0;

}

//错误形式：

//1.格式化文本中的类型与变量类型或数量对应错误

//可以通过编译，但结果可能与预期结果不一致

int main() {

int a = 1;

double b = 2.1;

char c = 'a';

char *s = "abcdefg";

int *p = NULL;

p = &a;

printf("%c", a);

printf("%*.*f", 3, b);

scanf("%lf", &a);

return 0;

}

//2.scanf不加或多加取址符&

int main() {

int a = 1;

int *p = NULL;

p = &a;

scanf("%d", a);

scanf("%d", &p);

return 0;

}

//———————————————————————- –

//正确形式：

int main() {

int a, b, c;

scanf("%d %d %d", &a, &b, &c);

if (a == b) {

//do something

} else if (b <= c) {

//do something

} else if (c >= a && c <= b) {

//do something

} else {

//do something

}

return 0;

}

//错误形式：

//1.逻辑运算符号错误, 引起程序逻辑分支出现问题，得不到正确结果

int main() {

int a, b, c;

scanf("%d %d %d", &a, &b, &c);

if (a = b) {

//do something

} else if (b <= c) {

//do something

} else if (a <= c <= b) {//注意！这种写法是错的！！

//do something

} else {

//do something

}

return 0;

}

//2.if else 级联写法错误，导致编译失败或者程序逻辑错误

//可能出现多余大括号，多余分号。缺少空格，或缺少分号

int main() {

int a, b, c;

scanf("%d %d %d", &a, &b, &c);

if (a == b) {

//do something

}elseif(b <= c) {

//do something

} else if (c >= a && c <= b);

{

//do something

} else {

//do something

};

return 0;

}

//———————————————————————- –

//正确形式：

int add(int x, int y);

int padd(int *x, int *y);

int main() {

int a = 1, b = 2;

int *pa, *pb;

pa = &a;

pb = &b;

printf("%d\n", add(a, b));

printf("%d\n", padd(&a, &b));

printf("%d\n", padd(pa, pb));

return 0;

}

int add(int x, int y) {

return x + y;

}

int padd(int *x, int *y) {

return *x + *y;

}

//错误形式：

//1.参数传递类型错误。

int add(int x, int y);

int padd(int *x, int *y);

int main() {

int a = 1, b = 2;

int *pa, *pb;

pa = &a;

pb = &b;

printf("%d\n", add(&a, &b));

printf("%d\n", padd(a, b));

printf("%d\n", padd(&pa, &pb));

return 0;

}

int add(int x, int y) {

return x + y;

}

int padd(int *x, int *y) {

return *x + *y;

}

//2.声明形式和实际形式不符

void add(int *x, int y);

double padd(int *x, int *y);

int main() {

int a = 1, b = 2;

int *pa, *pb;

pa = &a;

pb = &b;

printf("%d\n", add(a, b));

printf("%d\n", padd(&a, &b));

printf("%d\n", padd(pa, pb));

return 0;

}

float add(int x, int y) {

return x + y;

}

void padd(int *x, int *y) {

return *x + *y;

}

//———————————————————————-

//通过考试不是目的，提高自己的程序编写能力才是重要的~

//如果你看到了这里，感谢你的耐心！

//记的，细节决定成败。。

C基础系列教程导航

该系列文章内容可能来源我本人或者zhrmoe（他的主页：https://zhr.moe/）的编写。文章如果有错误欢迎批评指正，谢谢！转载请注明来自本站，另外，本系列教程中的代码建议初学者自己手打一遍，不要直接复制（由于某些奇怪的原因可能会导致你复制的代码出现错误！相信自己的双手吧=-=

如果链接不生效，请自行复制地址访问

计算机系列网课
http://study.163.com/curricula/cs.htm

翁恺 —— C语言程序设计
http://mooc.study.163.com/course/1000002011?tid=2001530003#/info

浙江大学基础练习网站
http://pta.patest.cn/pta/test/14/exam/4

C基础系列教程基本内容更新完毕，后期会逐步添加练习题和课后习题=-=
张浩然博客
https://zhr.moe

C基础系列教程1——基础数据类型以及输入输出语句

C基础系列教程1——基础数据类型以及输入输出语句

C基础系列教程2——逻辑表达式和判断语句

C基础系列教程2——逻辑表达式和判断语句

C基础系列教程3——switch和数组基础

C基础系列教程3——switch和数组基础

C基础系列教程4——简单循环

C基础系列教程4——简单循环

C基础系列教程5——多重循环

C基础系列教程5——多重循环

循环练习题2 HDOJ 2010
http://acm.hdu.edu.cn/showproblem.php?pid=2010

C基础系列教程6——函数

C基础系列教程6——函数

C基础系列教程7——指针1

C基础系列教程7——指针1

C基础系列教程8——指针2

C基础系列教程8——指针2

C基础系列教程9——指针3

C基础系列教程9——指针3

C基础系列教程10——结构体

C基础系列教程10——结构体

C基础系列教程11——常见错误总结

C基础系列教程11——常见错误总结

C基础系列教程10——结构体

该系列文章内容可能来源我本人或者zhrmoe（他的主页：https://zhr.moe）的编写。文章如果有错误欢迎批评指正，谢谢！转载请注明来自本站，另外，本系列教程中的代码建议初学者自己手打一遍，不要直接复制（由于某些奇怪的原因可能会导致你复制的代码出现错误！相信自己的双手吧=-=
如果你觉得进度太快，可以等你熟悉了前面的内容后再继续往下看

先思考一个问题：
（亲爱的小明出场）假如一个小组有10个同学，需要记录在程序中，其中几个同学分别叫小明、小红、小绿、小然、小琪、小玮、小霄·········（这些只是随便起的名字，臻的是随便起的233333）
现在需要分别记录TA们的编号、身高、体重什么的，为了方便写代码所以只出现数字，都是int，应该不会有越界情况发生（逃）。请思考如何声明变量。
先想想，再往下看
————————— 我是萌萌哒分割线 ●▽● —————————
你可能写出这样的代码（这是个错误的示范）


int xiaomingdeid;
int xiaomingdeshengao;
int xiaomingdetizhong;
int xiaoludeid;
int xiaoludeshengao;
int xiaoludetizhong;

int xiaomingdeid;

int xiaomingdeshengao;

int xiaomingdetizhong;

int xiaoludeid;

int xiaoludeshengao;

int xiaoludetizhong;

每个人的每个数据（以后可以称之为属性）都声明一个变量。这样当然是可以的（如果你不嫌累）。
顺便一说，变量的命名要简洁明了，不要这么啰嗦=-=并且不要用拼音。

不多嘛，30行就写完了。然后呢，等你写完之后突然有人又告诉你（客户改需求了），需要每个人再增加一个年龄。。你内心一定是这样的
————————— 我是萌萌哒分割线 ●▽● —————————
现在遇到的问题就是这样，今天介绍一个新的东西，struct。叫做结构体，一个结构体可以包括多个变量，定义方式如下。
你需要新建一个文件，文件名叫做person.h，这种后缀的文件我们称作头文件，内容是这样的


#ifndef _person_h
#define _person_h
struct person {
	int id;
	int height;
	int weight;
};
#endif

#ifndef _person_h

#define _person_h

struct person {

int id;

int height;

int weight;

};

#endif

这样就定义了1个结构体类型叫做person，注意不要丢了右大括号后面的那个分号。在主程序中我们需要在#include<stdio.h>的后面加一行 #include “person.h” ，这种自己写的头文件我们用双引号引起来以便于和C自带的头文件混淆。

接下来就可以定义变量了，代码是这样的。


int main() {
	struct person xiaoming;
	struct person xiaohong;
	xiaoming.id = 0;
	xiaoming.height = 180;
	xiaoming.weight = 150;
	xiaohong.id = 1;
	xiaohong.height = 160;
	xiaohong.weight = xiaoming.weight;
	system("pause");
	return 0;
}

int main() {

struct person xiaoming;

struct person xiaohong;

xiaoming.id = 0;

xiaoming.height = 180;

xiaoming.weight = 150;

xiaohong.id = 1;

xiaohong.height = 160;

xiaohong.weight = xiaoming.weight;

system("pause");

return 0;

}

第一行声明了一个叫做xiaoming的变量，这是个特殊的变量，因为它是个结构体，里面包含了刚刚定义的三个属性，id、身高、体重。我们使用.（这是一个点儿）来访问结构体变量中的属性给它赋值（当然也可以读取，比如最后一行）。

这样的话定义起来就会方便很多，增加属性的话直接去更改头文件的定义就好了。

————————— 我是萌萌哒分割线 ●▽● —————————
接下来会出现一个问题，你每次定义的时候都要敲一个struct person，这令人十分讨厌（主要还是懒）。所以呢，我们在把头文件改成这样


#ifndef _person_h
#define _person_h
struct _person {
	int id;
	int height;
	int weight;
};
typedef struct _person person;
#endif

#ifndef _person_h

#define _person_h

struct _person {

int id;

int height;

int weight;

};

typedef struct _person person;

#endif

我把原来的struct person改成了struct _person，加了一个下划线，是为了下面这样做，typedef的意思是定义一个新的类型，把struct _person 叫做person，也就是说你待会输入person就相当于输入了struct _person，这样就少写了一个单词（我臻是太懒了=-=）
那么这样做之后你会发现原来的程序报错了，因为我们加了个下划线，所以源程序有两种改法
第一种，跟着加下划线，这种方法显然更麻烦
第二种，直接删掉struct，这也是我们这样做的目的（其实还是为了偷懒）。

更改后代码如下，小红就删了啊=-=


int main() {
	person xiaoming; xiaoming.id = 0;
	xiaoming.height = 180;
	xiaoming.weight = 150; 
        printf("xiaoming.id = %d\n", xiaoming.id);
	printf("xiaoming.height = %d\n", xiaoming.height);
	printf("xiaoming.weight = %d\n\n", xiaoming.weight); 
	system("pause");
	return 0;
}

int main() {

person xiaoming; xiaoming.id = 0;

xiaoming.height = 180;

xiaoming.weight = 150;

printf("xiaoming.id = %d\n", xiaoming.id);

printf("xiaoming.height = %d\n", xiaoming.height);

printf("xiaoming.weight = %d\n\n", xiaoming.weight);

system("pause");

return 0;

}

————————— 我是萌萌哒分割线 ●▽● —————————
今天有时间，就接着往下写吧=-=一次看不完可以下次接着看

在数据结构中，不光要储存数据，还要对应数据的一些操作，这些操作的集合我们叫做操作集，也就是一堆函数。
所以，在数据结构中很少通过定义一个本地的变量来操作，都是通过函数来进行的，那么这里就有一个问题，在函数中对本地变量操作无法直接传参数，需要传地址，也就是指针。

所以需要更改声明为


//person xiaoming;
//person* addressOfxiaoming;
person* xiaoming = NULL;

//person xiaoming;

//person* addressOfxiaoming;

person* xiaoming = NULL;

第一行是原来的声明，需要改写成第二行的样子，之所以注释掉是因为太长（虽然更好理解，也就是小明所在内存中的地址），所以依然叫做xiaoming（还是太懒），现在你要注意，接下来的 “xiaoming” 的意思是小明所在的地址，不再是之前的xiaoming了。还有一点要注意，指针的声明要初始化为NULL，否则叫做野指针，不知道指向哪里。

我们来写一个函数来进行和之前同样的操作。主程序是这样的，注意多加了一个stdlib.h


#include <stdio.h>
#include <stdlib.h>
#include "person.h"
int main() {
	person* xiaoming; xiaoming = (person *)malloc(sizeof(person));
	fun(xiaoming); system("pause");
	return 0;
}

#include <stdio.h>

#include <stdlib.h>

#include "person.h"

int main() {

person* xiaoming; xiaoming = (person *)malloc(sizeof(person));

fun(xiaoming); system("pause");

return 0;

}

其中需要解释的是malloc这一行，意思是分配一块大小刚好能放得下person结构体的内存，这时候电脑并不知道这块内存要放什么，你需要强制类型转换成person指针类型来告诉电脑这里要放的是一个person。其中sizeof求出的是一个person占多大的内存，malloc负责向系统申请一块这么大的内存，然后返回一个内存的地址，但是是不知道类型的地址（也就是void *），最后强制转换成person*
这样的做法就相当于之前的person xiaoming;然后把小明的地址记下来。最后一行把小明的地址传给fun函数处理。

接下来写fun函数，我们接收到的是person的指针，叫做sb（somebody-_-||不要多想），这个sb就是一个指向了person的指针。


void fun(person * sb) { //这的意思是somebody-_-||不要多想
	(*sb).id = 0;
	(*sb).height = 180;
	(*sb).weight = 150;
	printf("xiaoming.id = %d\n", (*sb).id);
	printf("xiaoming.height = %d\n", (*sb).height);
	printf("xiaoming.weight = %d\n\n", (*sb).weight);
}

void fun(person * sb) { //这的意思是somebody-_-||不要多想

(*sb).id = 0;

(*sb).height = 180;

(*sb).weight = 150;

printf("xiaoming.id = %d\n", (*sb).id);

printf("xiaoming.height = %d\n", (*sb).height);

printf("xiaoming.weight = %d\n\n", (*sb).weight);

}

我们的做法和之前的整数交换差不多，*sb代表的是间接取出sb指向的内容，也就是小明，之后在用.（这是一个点儿）来访问小明的id、身高、体重。之所以加括号是因为那个“点”的运算优先级要高于间接取值的星号。
但是人总是懒的=-=又要打括号星号还有点太麻烦了→_→所以呢就有这这种写法，和上面完全等价


void fun(person * sb) { //这的意思是somebody-_-||不要多想
	sb->id = 0;
	sb->height = 180;
	sb->weight = 150;
	printf("xiaoming.id = %d\n", sb->id);
	printf("xiaoming.height = %d\n", sb->height);
	printf("xiaoming.weight = %d\n\n", sb->weight);
}

void fun(person * sb) { //这的意思是somebody-_-||不要多想

sb->id = 0;

sb->height = 180;

sb->weight = 150;

printf("xiaoming.id = %d\n", sb->id);

printf("xiaoming.height = %d\n", sb->height);

printf("xiaoming.weight = %d\n\n", sb->weight);

}

是的你没看错就是一个箭头，一个减号和一个大于号。
注意这俩符号中间不能加空格
注意这俩符号中间不能加空格
注意这俩符号中间不能加空格
重要的事情说三遍。

————————— 我是萌萌哒分割线 ●▽● —————————
补充说明：.(这是一个点)运算用在访问一个结构体变量的属性时，那个箭头用于指针指向的结构体属性时候，一个是直接访问一个是间接访问，后续还可能会出现结构体的属性指向结构体，就可能出现先箭头再一个点来访问，比如链表。。。这是小然提出来的补充哦（逃
————————— 我是萌萌哒分割线 ●▽● —————————
至此，数据结构基础告一段落，如果还有补充的我会继续发=-=
下面是我的github，这里有一些数据结构的源码。。。还在学习ing=-=（请勿抄袭！请勿抄袭！请勿抄袭！）

https://github.com/956237586/DataStructure-C/tree/master/DataStructure-C
————————— 我是萌萌哒分割线 ●▽● —————————
题外话，关于箭头还有个黑魔法，依然转自知乎 http://www.zhihu.com/question/27417946

C基础系列教程9——指针3

当你在C中需要储存大量的数据的时候，最常见的一种做法就是数组，今天将介绍数组和指针之间的关系，展示数组真实的模样。

本次主要为一维数组，多维数组就是一维数组的推广而已，可以仿照本文方法分析研究。

首先编写测试代码如下


int arr[5] = { 0 };
int *pa = &arr;
int i;
for (i = 0; i < 5; i++) {
	arr[i] = i;
}

int arr[5] = { 0 };

int *pa = &arr;

int i;

for (i = 0; i < 5; i++) {

arr[i] = i;

}

在这段程序中定义了一个整数数组，一个整数指针变量
断点调试观察内存的状态是这样的

这是整个数组，图中每个红框就是一个int，是数组中的一个单元，从下往上看，可以发现分别就是arr[4]一直到a[0]
————————我是萌萌哒分割线 ●▽●——————

这是指针pa
————————我是萌萌哒分割线 ●▽●——————
在接下来为了节省地方，我会把四个字节的内容放到一行，省略一些地址的显示，如下图

————————我是萌萌哒分割线 ●▽●——————

这两张和之前的两张意思是一样的，只是省略了部分地址的显示，便于观察，看的时候从下向上，从右至左
————————我是萌萌哒分割线 ●▽●——————

观察上图不难发现，取数组的地址的结果就是数组最开始的地址，指针也指向这个位置。继续增加代码如下


#include <stdio.h>
int main() {
	int arr[5] = { 0 };
	int *pa = &arr;
	int i;

	for (i = 0; i < 5; i++) {
		arr[i] = i;
	}

	printf("arr = %p\n", arr);
	printf("&arr[0] = %p\n", &arr[0]);
	printf("arr[0] = %d\n", arr[0]);

	printf("pa = %p\n", pa);
	printf("*pa = %d\n", *pa);

	printf("&arr[2] = %p\n", &arr[2]);
	printf("arr[2] = %d\n", arr[2]);

	printf("pa + 2 = %p\n", pa + 2);
	printf("*(pa + 2) = %d\n", *(pa + 2));

	system("pause");
	return 0;
}

#include <stdio.h>

int main() {

int arr[5] = { 0 };

int *pa = &arr;

int i;

for (i = 0; i < 5; i++) {

arr[i] = i;

}

printf("arr = %p\n", arr);

printf("&arr[0] = %p\n", &arr[0]);

printf("arr[0] = %d\n", arr[0]);

printf("pa = %p\n", pa);

printf("*pa = %d\n", *pa);

printf("&arr[2] = %p\n", &arr[2]);

printf("arr[2] = %d\n", arr[2]);

printf("pa + 2 = %p\n", pa + 2);

printf("*(pa + 2) = %d\n", *(pa + 2));

system("pause");

return 0;

}

运行结果如图

让我们来一行一行的分析
第1行、第2行、第4行，如果我们尝试直接打印数组名字，会发现打印出来的就会和数组第一个元素的结果是一样的，和指针的内容也是一样的，这说明，数组的名字就代表了数组的首元素地址。指针指向数组的时候也会指向这个数组的首元素地址。

当然，打印出来的arr[0]也肯定会和*pa一样，因为pa的值就是第一个元素的地址。这没什么好解释的，自习对照上面的内存截图很容易就能看出来。

接下来我拿第3个元素作为例子，也就是arr[2]，剩下的几行你会发现，pa + 2 我们称作指针的偏移，偏移2个单位，由于一个整数占4个字节也就是四个格子，所以也就偏移到了数组中的第3个数字，你可以把2改成其他值观察结果是怎样的，最后的结果你会发现实际上arr[2]的含义可以理解为从数组首地址也就是arr先偏移2再取值，也就是最后一行写的那样。

（题外话，这里还有个黑魔法，转自知乎）

如果你明白了刚才说的数组，那么这个黑魔法的原理你也一定能很快的想明白，这个就留给大家思考吧=-=
温馨提示，你可以编写一些代码验证这个黑魔法，断点调试观察内存，尝试更换等价表达式来验证你的猜想是否正确

下次介绍struct的基本使用

C基础系列教程8——指针2

上次我们说到，指针的一个用途，可以当作参数传递给函数进行使用，废话不说，直接上代码


void swap2(int *pa, int *pb) {
	int t = *pa;
	*pa = *pb;
	*pb = t;
}

void swap2(int *pa, int *pb) {

int t = *pa;

*pa = *pb;

*pb = t;

}

一定要记的上次说的，星号的两种使用，一种是在声明的时候，代表变量类型为指针，第二种是使用的时候根据指针所指的地址间接取值。同理，在参数的声明时候也一样。在上面的代码中，声明了两个参数，类型都是整数指针，也就是将要储存整数变量所在地址的变量（有点绕，配合上次的内存截图理解），接下来的三行是整数交换的操作。注意，t是一个局部的整数变量，pa是个整数指针，只有间接取值的结果才是一个整数。同理，*pb代表的是pb指向位置的内容，这是第三个星号的使用：间接的存储。这三行看似简单，但是如果不能理解指针就会非常容易出错，究竟是不是应该加星号是最容易纠结的地方。接下来的几张图将表示函数执行的过程（图中的地址只是为了便于理解，并不符合真实内存的分配规律，上次的截图才是真实的内存状态）。

假设两个数 a = 1， b = 2，调用语句是这样的swap2(&a, &b); 这样就传入了两个变量的地址。

传入的地址的值会被原封不动复制到pa和pb两个新的指针变量的内容中，如上图

第1行，分配一块内存当作t，并且存入pa所指向的内容，如上图

第2行，改写pa指向地址的值，如上图

第3行，改写pb指向地址的值，如上图

最后，函数结束，回收pa，pb，t三个变量占用的内存，如上图

这就是通过传入地址来间接交换两个变量，你可以用下面的代码观察结果


#include <stdio.h>
void swap1(int a, int b) {
	int t = a;
	printf("In swap1:\n");
	printf("a = %d, b = %d\n", a, b);
	a = b;
	b = t;
	printf("a = %d, b = %d\n", a, b);
	printf("swap1 end\n");
}
void swap2(int *pa, int *pb) {
	int t = *pa;
	printf("In swap2:\n");
	printf("a = %d, b = %d\n", *pa, *pb);
	*pa = *pb;
	*pb = t;
	printf("a = %d, b = %d\n", *pa, *pb);
	printf("swap2 end\n");
}
int main() {
	int a = 1;
	int b = 2;
	//int *pa = &a, pb = &pb;(注意这是错误的写法，每个变量声明都要加星号)
	int *pa = &a, *pb = &b;
	printf("In main:\n");
	printf("Before swap1\n");
	printf("a = %d, b = %d\n", a, b);
	swap1(a, b);
	printf("a = %d, b = %d\n", a, b);
	printf("Before swap2\n");
	printf("a = %d, b = %d\n", a, b);
	swap2(&a, &b);
	printf("a = %d, b = %d\n", a, b);
	printf("main end\n");
	system("pause");
	return 0;
}

#include <stdio.h>

void swap1(int a, int b) {

int t = a;

printf("In swap1:\n");

printf("a = %d, b = %d\n", a, b);

a = b;

b = t;

printf("a = %d, b = %d\n", a, b);

printf("swap1 end\n");

}

void swap2(int *pa, int *pb) {

int t = *pa;

printf("In swap2:\n");

printf("a = %d, b = %d\n", *pa, *pb);

*pa = *pb;

*pb = t;

printf("a = %d, b = %d\n", *pa, *pb);

printf("swap2 end\n");

}

int main() {

int a = 1;

int b = 2;

//int *pa = &a, pb = &pb;(注意这是错误的写法，每个变量声明都要加星号)

int *pa = &a, *pb = &b;

printf("In main:\n");

printf("Before swap1\n");

printf("a = %d, b = %d\n", a, b);

swap1(a, b);

printf("a = %d, b = %d\n", a, b);

printf("Before swap2\n");

printf("a = %d, b = %d\n", a, b);

swap2(&a, &b);

printf("a = %d, b = %d\n", a, b);

printf("main end\n");

system("pause");

return 0;

}

为了更好的理解值传递，下面的几张图将表示上一次的交换函数执行过程，也就是上面代码中的swap1，一样假设两个数a = 1, b = 2(图中的地址只是为了便于理解，并不符合真实内存的分配规律，上次的截图才是真实的内存状态）。

—————————我是萌萌哒分割线 ●▽● ———————————

参数传入后会像上次说的那样原封不动的复制一份到新的参数中，虽然同名（也可以不同名），但是本质上已经不是同一个变量了，如上图所示
—————————我是萌萌哒分割线 ●▽● ———————————

—————————我是萌萌哒分割线 ●▽● ———————————

—————————我是萌萌哒分割线 ●▽● ———————————

—————————我是萌萌哒分割线 ●▽● ———————————

最后，函数结束，回收a，b，t三个变量占用的内存，如上图
—————————我是萌萌哒分割线 ●▽● ———————————
下次介绍指针与数组的关系

C基础系列教程7——指针1

接下来主要是指针和结构体的使用，以及堆内存的分配。这些内容非常非常非常重要，将会在数据结构中大量使用，如果这些不懂，写数据结构的代码会比较困难。

首先是指针的使用，请思考，如何写一个函数，实现两个参数内容的交换？
比如我传入a = 1, b = 2,要求用函数交换这两个内容，你可能会写出这样的代码


void swap1(int a, int b) {
    int t = a;
    a = b;
    b = t;
}

void swap1(int a, int b) {

int t = a;

a = b;

b = t;

}

最初的想法一定是这样的，你肯定会想，直接把两个变量交换一下不就结了- –
你可以使用这段代码来测试这个函数


#include <stdio.h>
void swap1(int a, int b) {
	int t = a;
	printf("In swap1:\n");
	printf("a = %d, b = %d\n", a, b);
	a = b;
	b = t;
	printf("a = %d, b = %d\n", a, b);
	printf("swap1 end\n");
}
int main() {
	int a = 1;
	int b = 2;
	printf("Before swap1\n");
	printf("a = %d, b = %d\n", a, b);
	swap1(a, b);
	printf("a = %d, b = %d\n", a, b);
	system("pause");
	return 0;
}

#include <stdio.h>

void swap1(int a, int b) {

int t = a;

printf("In swap1:\n");

printf("a = %d, b = %d\n", a, b);

a = b;

b = t;

printf("a = %d, b = %d\n", a, b);

printf("swap1 end\n");

}

int main() {

int a = 1;

int b = 2;

printf("Before swap1\n");

printf("a = %d, b = %d\n", a, b);

swap1(a, b);

printf("a = %d, b = %d\n", a, b);

system("pause");

return 0;

}

你会发现运行结果是这样的
当swap1之中结束之前，两个变量的值还是被交换的，但是当回到主函数中的时候，两个变量的值又回到了交换前的状态。
原因是这样的，函数的参数在主程序时候传入的那个a，和函数中的a，在这个例子中名字都是a，但实际上确实两个不同的变量，当传入一个参数给函数时候，电脑会把传入的参数变量原封不动的复制一遍，当函数执行完毕后，复制出来的那份变量会被电脑销毁。所以当你在swap1中交换两个变量的时候，实际操作的是复制出来的那份a和b，原来的那份a和b根本就没被交换，所以才会出现函数执行之后回到交换之前的状态。

那么怎么解决这个问题呢？
变量实际上是存在内存中的，你可以想象成一个巨大的表格，每个单元格有自己的地址，如图所示，左侧的0xXXXXXXXX是个16进制的数字，就是这个单元格的地址，可以理解为这个格子的编号。执行完int a = 1;之后，电脑就会分配4个单元格（4个字节）当作变量a，并且把内容改为00000001（从下往上看，栈内存分配是从高到低分配，不懂也没关系，不要在意这些细节）
想一下，函数参数的传递既然都是值传递（也就是刚才说的原封不动的复制一份以前的内容放到一个新的地方），那么可不可以把单元格的地址传给函数，在函数内部更改指定地址的内容呢？答案是可以的，这样就引出了指针，我们把储存内存地址的变量叫做指针，如下图，储存了上图中变量a的地址。接下来介绍指针的基本语法
在C语言中，我们使用*来声明一个指针变量（也可以称作地址变量），使用&符号取一个变量的地址（这下知道为什么scanf的时候不能忘记&符号了吧），使用*来取出指针所指向地址中的内容（也就是取值），示例代码如下


#include<stdio.h>
int main() {
	int a = 5;
	int* pa = &a;
	printf("&a = %p\n", &a);
	printf("a = %d\n", a);
	printf("&pa = %p\n", &pa);
	printf("pa = %p\n", pa);
	printf("*pa = %d\n", *pa);
	system("pause");
	return 0;
}

#include<stdio.h>

int main() {

int a = 5;

int* pa = &a;

printf("&a = %p\n", &a);

printf("a = %d\n", a);

printf("&pa = %p\n", &pa);

printf("pa = %p\n", pa);

printf("*pa = %d\n", *pa);

system("pause");

return 0;

}

需要注意的是，要注意区分两次星号的意义，第一个星号是声明一个整数类型的指针（四个字节，储存的是地址），第二个星号的意思是，先取出pa中的地址，再取出这个地址中的内容，是个间接的访问。（补充一点，在printf中%p用来显示内存地址，%d就不用说了吧）
你可以多次运行这段代码观察结果的规律，内存状态如下图所示。需要注意的是，你的运行结果和我图中结果一样的几率很小，但是规律肯定是一样的，因为每次运行电脑分配的内存都不一样。后两张是内存的状态，注意观察规律。

下一次介绍指针的应用之一，当作参数传递给函数，这样就可以解决开始提出的问题。。。
转载请注明出处，谢谢！