C语言----变量及作用域 、 指针 、 指针和数组 、 进程空间 、 字符串

1 使用程序来模拟放球、取球的问题

1.1 问题

栈是一种特殊的线性表，它的逻辑结构和线性表相同，只是其运算规则较线性表有更多的限制，故又称为运算受限的线性表。

栈的定义是限制仅在表的一端进行插入和删除运算的线性表。

1) 通常称插入、删除的这一端为栈顶（Top），另一端称为栈底（Bottom）。

2) 当表中没有元素时称为空栈。

3) 栈为后进先出（Last In First Out）的线性表，简称为LIFO表。

栈的修改是按后进先出的原则进行。每次删除（退栈）的总是当前栈中"最新"的元素，即最后插入（进栈）的元素，而最先插入的是被放在栈的底部，要到最后才能删除。

栈的基本运算有：

1) init（S）

构造一个空栈S。

2) empty（S）

判栈空。若S为空栈，则返回TRUE，否则返回FALSE。

3) full（S）

判栈满。若S为满栈，则返回TRUE，否则返回FALSE。

注意：该运算只适用于栈的顺序存储结构。

4) push（S，x）

进栈。若栈S不满，则将元素x插入S的栈顶。

5) pop（S）

退栈。若栈S非空，则将S的栈顶元素删去，并返回该元素。

6) top（S）

取栈顶元素。若栈S非空，则返回栈顶元素，但不改变栈的状态。

1.2 方案

本案例是栈的一个应用，用数字来代表球，向栈中放入一个数字1代表放入了1号球，向栈中放入一个数字2代表放入了2号球，依次类推。同样，从栈中取出数字1代表取出了1号球。

1.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义栈的结构

代码如下：

1. #define LISTSIZE 10
2. typedef int DataType;
3. struct Stack {
4. DataType data[LISTSIZE];
5. int top; //处了记录大小 还可以记录栈顶位置
6. };

上述代码中，下面的代码行：

1. #define LISTSIZE 10

定义了一个宏名，用它来表示栈的容量。

上述代码中，代码行：

1. typedef int DataType;

为关键字int起一个别名叫DataType。此时，语句int a；与语句DataType a；是等效的，都是定义的了两个整型变量。

上述代码中，代码行：

1. struct Stack {
2. DataType data[LISTSIZE];
3. int top; //处了记录大小 还可以记录栈顶位置
4. };

定义了一个结构体，一个结构体内可以有多个数据成员。如本案例中的结构体就有两个数据成员，一个是整型数组data，用它来模拟栈，每个数组元素的位置都可以存放一个栈元素；另一个是整型变量top，用它来模拟栈顶指针。

步骤二：初始化一个结构体

代码如下：

1. #include <stdio.h>
2. #include <stdbool.h>
3. #define LISTSIZE 10
4. typedef int DataType;
5. struct Stack {
6. DataType data[LISTSIZE];
7. int top; //处了记录大小 还可以记录栈顶位置
8. };
9. void init(struct Stack* stack){
10. stack->top = 0;
11. }
12. int main()
13. {
14. struct Stack s;
15. init(&s);
16. return 0;
17. }

上述代码中，下面代码行：

1. struct Stack s;

是在主程序中，定义一个结构体变量s，用它来模拟栈，在本案例中将向栈中放入球。

上述代码中，下面代码行：

1. init(&s);

是调用初始化栈函数，实参是结构体变量s的地址。

上述代码中，下面代码行：

1. void init(struct Stack* stack){
2. stack->top = 0;
3. }

是初始化栈函数的定义，该函数有一个形参，用于接收结构体变量的指针。在这个函数的函数体中，语句stack->top=0;表示将结构体变量stack中的整型变量成员top赋值为0，符号->被称为成员运算符，它的作用是将结构体变量中的某个成员取出来进行操作，像上面就是赋值操作。

步骤二：判断栈空、栈满

代码如下：

1. #include <stdio.h>
2. #include <stdbool.h>
3. #define LISTSIZE 10
4. typedef int DataType;
5. struct Stack {
6. DataType data[LISTSIZE];
7. int top; //处了记录大小 还可以记录栈顶位置
8. };
9. void init(struct Stack* stack){
10. stack->top = 0;
11. }
12. bool empty(struct Stack* stack) {
13. return stack->top == 0;
14. }
15. bool full(struct Stack* stack) {
16. return stack->top == LISTSIZE;
17. }
18. int main()
19. {
20. struct Stack s;
21. init(&s);
22. return 0;
23. }

上述代码中，下面代码行：

1. bool empty(struct Stack* stack) {
2. return stack->top == 0;
3. }

是判断栈空函数，函数接受一个结构体变量指针，在函数体内，如果栈顶指针stack->top等于0时，代表栈空。

上述代码中，下面代码行：

1. bool full(struct Stack* stack) {
2. return stack->top == LISTSIZE;
3. }

是判断栈满函数，函数接受一个结构体变量指针，在函数体内，如果栈顶指针stack->top等于栈容量LISTSIZE时，代表栈满。

步骤三：入栈操作

代码如下：

1. #include <stdio.h>
2. #include <stdbool.h>
3. #define LISTSIZE 10
4. typedef int DataType;
5. struct Stack {
6. DataType data[LISTSIZE];
7. int top; //处了记录大小 还可以记录栈顶位置
8. };
9. void init(struct Stack* stack){
10. stack->top = 0;
11. }
12. bool empty(struct Stack* stack) {
13. return stack->top == 0;
14. }
15. bool full(struct Stack* stack) {
16. return stack->top == LISTSIZE;
17. }
18. void push(struct Stack* stack, DataType d) {
19. if (full(stack))
20. return;
21. stack->data[stack->top++] = d;
22. }
23. int main()
24. {
25. struct Stack s;
26. init(&s);
27. push(&s, 1);
28. push(&s, 2);
29. push(&s, 3);
30. push(&s, 4);
31. return 0;
32. }

上述代码中，下面代码行：

1. push(&s, 1);

是调用入栈函数，向栈s中放入一个整型数据1，即放入1号球。

上述代码中，下面代码行：

1. void push(struct Stack* stack, DataType d) {
2. if (full(stack))
3. return;
4. stack->data[stack->top++] = d;
5. }

是入栈函数，函数包含两个形参，第一个形参是一个指向结构体Stack的指针，它的作用是表示向哪个栈中放入数据；第二个形参是向栈中放入的数据是什么。函数体首先判断栈是否已经满，如果栈满就不能继续向栈中加入数据。如果栈不满，语句stack->data[stack->top++] = d;将数据d放入栈stack->data[]当中。栈顶指针stack->top指示出数据加入的位置，当数据加入完成后，栈顶指针stack->top加1，指向下一个位置。

步骤四：出栈操作和取栈顶元素操作

代码如下：

1. #include <stdio.h>
2. #include <stdbool.h>
3. #define LISTSIZE 10
4. typedef int DataType;
5. struct Stack {
6. DataType data[LISTSIZE];
7. int top; //处了记录大小 还可以记录栈顶位置
8. };
9. void init(struct Stack* stack){
10. stack->top = 0;
11. }
12. bool empty(struct Stack* stack) {
13. return stack->top == 0;
14. }
15. bool full(struct Stack* stack) {
16. return stack->top == LISTSIZE;
17. }
18. void push(struct Stack* stack, DataType d) {
19. if (full(stack))
20. return;
21. stack->data[stack->top++] = d;
22. }
23. void pop(struct Stack* stack) {
24. if (empty(stack))
25. return;
26. stack->top--;
27. }
28. DataType top(struct Stack* stack) {
29. return stack->data[stack->top - 1];
30. }
31. int main()
32. {
33. struct Stack s;
34. init(&s);
35. push(&s, 1);
36. push(&s, 2);
37. push(&s, 3);
38. push(&s, 4);
39. printf("%d\n", top(&s));
40. pop(&s);
41. printf("%d\n", top(&s));
42. pop(&s);
43. printf("%d\n", top(&s));
44. pop(&s);
45. printf("%d\n", top(&s));
46. pop(&s);
47. return 0;
48. }

上述代码中，下面代码行：

1. printf("%d\n", top(&s));

是调用取栈顶元素函数top(&s)，将栈s中最后放入的数据取出来。

上述代码中，下面代码行：

1. DataType top(struct Stack* stack) {
2. return stack->data[stack->top - 1];
3. }

是取栈顶元素函数，函数带有一个形参，表示从哪个栈中取出元素。函数体中的语句stack->data[stack->top - 1];表示将栈顶指针stack->top减1的位置的栈元素stack->data[]取出来。

上述代码中，下面代码行：

1. pop(&s);

是调用出栈函数。将栈s的地址作为实参。

上述代码中，下面代码行：

1. void pop(struct Stack* stack) {
2. if (empty(stack))
3. return;
4. stack->top--;
5. }

是出栈函数，函数带有一个形参，表示从哪个栈中出栈。函数体首先判断栈是否为空，如果栈空，表示栈中已经没有元素，就不能再出栈了。然后将栈顶指针stack->top减1，表示栈中的元素少了一个。

1.4 完整代码

本案例的完整代码如下所示：

1. #include <stdio.h>
2. #include <stdbool.h>
3. #define LISTSIZE 10
4. typedef int DataType;
5. struct Stack {
6. DataType data[LISTSIZE];
7. int top; //处了记录大小 还可以记录栈顶位置
8. };
9. void init(struct Stack* stack){
10. stack->top = 0;
11. }
12. bool empty(struct Stack* stack) {
13. return stack->top == 0;
14. }
15. bool full(struct Stack* stack) {
16. return stack->top == LISTSIZE;
17. }
18. void push(struct Stack* stack, DataType d) {
19. if (full(stack))
20. return;
21. stack->data[stack->top++] = d;
22. }
23. void pop(struct Stack* stack) {
24. if (empty(stack))
25. return;
26. stack->top--;
27. }
28. DataType top(struct Stack* stack) {
29. return stack->data[stack->top - 1];
30. }
31. int main()
32. {
33. struct Stack s;
34. init(&s);
35. push(&s, 1);
36. push(&s, 2);
37. push(&s, 3);
38. push(&s, 4);
39. printf("%d\n", top(&s));
40. pop(&s);
41. printf("%d\n", top(&s));
42. pop(&s);
43. printf("%d\n", top(&s));
44. pop(&s);
45. printf("%d\n", top(&s));
46. pop(&s);
47. return 0;
48. }

2 求一组数的最大值、最小值

2.1 问题

创建程序，实现以下的功能：编制一个自定义函数同时返回一组数的最大值、最小值

需求为：在主函数中创建一个长度为10的数组，数组内放置10个0~99之间（包含0，包含99）的随机数作为数组内容，按要求编制一个自定义函数同时返回数组中的最大值、最小值，然后在主函数中将自定义函数的返回值打印显示在界面上。控制台效果如图-1所示：

图-1

2.2 方案

首先，定义一个函数，功能是求数组中的最大值与最小值。

然后，在主函数中，定义一个长度为10的数组，并将10个数组元素分别赋值为10个随机数，然后调用以上编制的函数，求出最大值、最小值，并在主函数中显示结果。

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：在主函数中定义数组

在主函数中，定义一个数组，并为每个数组元素赋值成一个随机数，然后将数组中数据显示出来。

代码如下：

1. #include <stdio.h>
2. #include <time.h>
3. #include <stdlib.h>
4. int main(int argc, const char * argv[])
5. {
6. int data[10];
7. srand((unsigned)time(0));
8. for (int i = 0; i < 10; i++)
9. data[i] = rand() % 100;
10. printf("数组中的数据为：");
11. for (int i = 0; i < 10; i++)
12. printf("%d ", data[i]);
13. printf("\n");
14. return 0;
15. }

步骤二：定义函数求最大值与最小值

代码如下：

1. #include <stdio.h>
2. #include <time.h>
3. #include <stdlib.h>
4. void maxAndMin(int data[], int size, int *max, int *min)
5. {
6. *max = data[0];
7. *min = data[0];
8. for (int i = 0; i < size; i++)
9. {
10. if (*max < data[i])
11. *max = data[i];
12. if (*min > data[i])
13. *min = data[i];
14. }
15. }
16. int main(int argc, const char * argv[])
17. {
18. int data[10];
19. srand((unsigned)time(0));
20. for (int i = 0; i < 10; i++)
21. data[i] = rand() % 100;
22. printf("数组中的数据为：");
23. for (int i = 0; i < 10; i++)
24. printf("%d ", data[i]);
25. printf("\n");
26. return 0;
27. }

上述代码中，下面代码行：

1. void maxAndMin(int data[], int size, int *max, int *min)

是自定义函数的函数头，该函数为无返回值函数，函数名为maxAndMin，函数有四个形参，第一个形参为一个数组，在此数组中找到最大值和最小值；第二个形参为数组的长度；第三个形参是一个指针变量，此参数用于将数组中的最大值带回主函数；第四个形参也是一个指针变量，此参数用于将数组中的最小值带回主函数。

上述代码中，下面代码行：

1. *max = data[0];
2. *min = data[0];

首先假定数组的最大值与最小值都是数组的第一个元素。

上述代码中，下面代码行：

1. for (int i = 0; i < size; i++)
2. {
3. if (*max < data[i])
4. *max = data[i];
5. if (*min > data[i])
6. *min = data[i];
7. }

遍历数组，逐个元素与最大值和最小值对比，如果比最大值大，替换最大值；如果比最小值小，则替换最小值。

步骤三：在主函数中调用

代码如下：

1. #include <stdio.h>
2. #include <time.h>
3. #include <stdlib.h>
4. void maxAndMin(int data[], int size, int *max, int *min)
5. {
6. *max = data[0];
7. *min = data[0];
8. for (int i = 0; i < size; i++)
9. {
10. if (*max < data[i])
11. *max = data[i];
12. if (*min > data[i])
13. *min = data[i];
14. }
15. }
16. int main(int argc, const char * argv[])
17. {
18. int data[10];
19. srand((unsigned)time(0));
20. for (int i = 0; i < 10; i++)
21. data[i] = rand() % 100;
22. printf("数组中的数据为：");
23. for (int i = 0; i < 10; i++)
24. printf("%d ", data[i]);
25. printf("\n");
26. int max;
27. int min;
28. maxAndMin(data, 10, &max, &min);
29. printf("最大值为：%d\n", max);
30. printf("最小值为：%d\n", min);
31. return 0;
32. }

上述代码中，下面代码行：

1. int max;
2. int min;

定义两个变量，分别用于存储数组中的最大值和最小值。

上述代码中，下面代码行：

1. maxAndMin(data, 10, &max, &min);

调用maxAndMin函数，数组data作为第一个实参，第二个实参是数组data的长度，第三个实参是变量max的地址，这样可以将最大值带回来，第四个实参是变量min的地址，它用于带回最小值。

2.4 完整代码

本案例的完整代码如下所示：

1. #include <stdio.h>
2. #include <time.h>
3. #include <stdlib.h>
4. void maxAndMin(int data[], int size, int *max, int *min)
5. {
6. *max = data[0];
7. *min = data[0];
8. for (int i = 0; i < size; i++)
9. {
10. if (*max < data[i])
11. *max = data[i];
12. if (*min > data[i])
13. *min = data[i];
14. }
15. }
16. int main(int argc, const char * argv[])
17. {
18. int data[10];
19. srand((unsigned)time(0));
20. for (int i = 0; i < 10; i++)
21. data[i] = rand() % 100;
22. printf("数组中的数据为：");
23. for (int i = 0; i < 10; i++)
24. printf("%d ", data[i]);
25. printf("\n");
26. int max;
27. int min;
28. maxAndMin(data, 10, &max, &min);
29. printf("最大值为：%d\n", max);
30. printf("最小值为：%d\n", min);
31. return 0;
32. }

3 输入输出个人信息

3.1 问题

在控制台上首先输入某个学生的个人信息，包括姓名、年龄、毕业院校，然后输出。效果图如图-2所示：

图-2

3.2 方案

定义数组和变量用于存储学生的个人信息，然后使用scanf函数输入该信息，最后再使用printf函数输出该信息。

3.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义数据

数组name，用于存储学生的姓名。

变量age，用于存储学生的年龄。

数组school，用于存储学生的毕业院校。

代码如下：

1. #include <stdio.h>
2. int main(int argc, const char * argv[])
3. {
4. char name[20];
5. int age;
6. char school[100];
7. return 0;
8. }

步骤二：输入学生的个人信息

使用scanf函数输入学生的姓名、年龄和毕业院校。

注意：数组使用用占位符%s。

代码如下：

1. #include <stdio.h>
2. int main(int argc, const char * argv[])
3. {
4. char name[20];
5. int age;
6. char school[100];
7. printf("请输入学生的姓名：");
8. scanf("%s", name);
9. printf("请输入学生的年龄：");
10. scanf("%d", &age);
11. printf("请输入学生的毕业院校：");
12. scanf("%s", school);
13. printf("\n");
14. return 0;
15. }

步骤三：输出学生的个人信息

使用printf函数输出学生的姓名、年龄和毕业院校。

代码如下：

1. #include <stdio.h>
2. int main(int argc, const char * argv[])
3. {
4. char name[20];
5. int age;
6. char school[100];
7. printf("请输入学生的姓名：");
8. scanf("%s", name);
9. printf("请输入学生的年龄：");
10. scanf("%d", &age);
11. printf("请输入学生的毕业院校：");
12. scanf("%s", school);
13. printf("\n");
14. printf("学生的个人信息如下：\n");
15. printf("姓名：%s\n", name);
16. printf("年龄：%d\n", age);
17. printf("毕业院校：%s\n", school);
18. return 0;
19. }

3.4 完整代码

本案例的完整代码如下所示：

1. #include <stdio.h>
2. int main(int argc, const char * argv[])
3. {
4. char name[20];
5. int age;
6. char school[100];
7. printf("请输入学生的姓名：");
8. scanf("%s", name);
9. printf("请输入学生的年龄：");
10. scanf("%d", &age);
11. printf("请输入学生的毕业院校：");
12. scanf("%s", school);
13. printf("\n");
14. printf("学生的个人信息如下：\n");
15. printf("姓名：%s\n", name);
16. printf("年龄：%d\n", age);
17. printf("毕业院校：%s\n", school);
18. return 0;
19. }