一，实验目的
1，深度理解使用指针变量间接访问数据，代码
2，会使用指针变量间接访问一维数组元素，二维数组元素
3，会使用指针变量处理字符串
4，会使用指针变量作为函数参数（形参，实参）和返回值
5，能灵活应用数组，指针，函数，编程解决实际问题
二，实验准备
使用指针间接访问数组（一维，两维）
指针作为函数参数
使用指针，指针数组处理字符串
指针数组在带有参数的main()函数中的用法
三，实验内容
1. 实验任务1
代码：
代码一：
1 #include <stdio.h>
2 #define N 5
3
4 void input(int x[], int n);
5 void output(int x[], int n);
6 void find_min_max(int x[], int n, int *pmin, int *pmax);
7
8 int main() {
9 int a[N];
10 int min, max;
11
12 printf("录入%d个数据:\n", N);
13 input(a, N);
14
15 printf("数据是: \n");
16 output(a, N);
17
18 printf("数据处理...\n");
19 find_min_max(a, N, &min, &max);
20
21 printf("输出结果:\n");
22 printf("min = %d, max = %d\n", min, max);
23
24 return 0;
25 }
26
27 void input(int x[], int n) {
28 int i;
29
30 for(i = 0; i < n; ++i)
31 scanf("%d", &x[i]);
32 }
33
34 void output(int x[], int n) {
35 int i;
36
37 for(i = 0; i < n; ++i)
38 printf("%d ", x[i]);
39 printf("\n");
40 }
41
42 void find_min_max(int x[], int n, int *pmin, int *pmax) {
43 int i;
44
45 *pmin = *pmax = x[0];
46
47 for(i = 0; i < n; ++i)
48 if(x[i] < *pmin)
49 *pmin = x[i];
50 else if(x[i] > *pmax)
51 *pmax = x[i];
52 }
代码二：
1 #include <stdio.h>
2 #define N 5
3
4 void input(int x[], int n);
5 void output(int x[], int n);
6 int *find_max(int x[], int n);
7
8 int main() {
9 int a[N];//变量定义在函数内部的开头
10 int *pmax;
11
12 printf("录入%d个数据:\n", N);
13 input(a, N);
14
15 printf("数据是: \n");
16 output(a, N);
17
18 printf("数据处理...\n");
19 pmax = find_max(a, N);
20
21 printf("输出结果:\n");
22 printf("max = %d\n", *pmax);
23
24 return 0;
25 }
26
27 void input(int x[], int n) {
28 int i;
29
30 for(i = 0; i < n; ++i)
31 scanf("%d", &x[i]);//&取地址符
32 }
33
34 void output(int x[], int n) {
35 int i;
36
37 for(i = 0; i < n; ++i)
38 printf("%d ", x[i]);
39 printf("\n");
40 }
41
42 int *find_max(int x[], int n) {
43 int max_index = 0;
44 int i;
45
46 for(i = 0; i < n; ++i)
47 if(x[i] > x[max_index])
48 max_index = i;
49
50 return &x[max_index];
51 }
运行截图：
代码一：
代码二：
问题回答：
代码一：
1，函数find_min_max实现从输入的数据中找到并返回最大最小值
2，pmax指向的地址用数组x的第一个值x[0]进行了初始化
3，pmin指向的另一个地址用pmax指向的的值x[0]进行了初始化
代码二：
1，find_max的功能是返回指向最大值的指针
2，可以的。测试结果是相同的。这个代码实现在内部定义一个指向最大值的指针，并用x的第一个值的地埋为这个指针进行了初始化，如果有大于指针里的地址对应的内容的if(x[i] > *ptr) ptr = &x[i]; ，就让这个指针的指向的地址变更为新的更大值的地址，最后仍然返回这个最大值的指针不同的是里面所指向的内容为最大值的地址了。
2. 实验任务2
代码：
代码一：
1 #include <stdio.h>
2 #include <string.h>
3 #define N 80
4
5 int main() {
6 char s1[N] = "Learning makes me happy";
7 char s2[N] = "Learning makes me sleepy";
8 char tmp[N];
9
10 printf("sizeof(s1) vs. strlen(s1): \n");
11 printf("sizeof(s1) = %d\n", sizeof(s1));
12 printf("strlen(s1) = %d\n", strlen(s1));
13
14 printf("\nbefore swap: \n");
15 printf("s1: %s\n", s1);
16 printf("s2: %s\n", s2);
17
18 printf("\nswapping...\n");
19 strcpy(tmp, s1);
20 strcpy(s1, s2);
21 strcpy(s2, tmp);
22
23 printf("\nafter swap: \n");
24 printf("s1: %s\n", s1);
25 printf("s2: %s\n", s2);
26
27 return 0;
28 }
代码二：
1 #include <stdio.h>
2 #include <string.h>
3 #define N 80
4
5 int main() {
6 char *s1 = "Learning makes me happy";
7 char *s2 = "Learning makes me sleepy";
8 char *tmp;
9
10 printf("sizeof(s1) vs. strlen(s1): \n");
11 printf("sizeof(s1) = %d\n", sizeof(s1));
12 printf("strlen(s1) = %d\n", strlen(s1));
13
14 printf("\nbefore swap: \n");
15 printf("s1: %s\n", s1);
16 printf("s2: %s\n", s2);
17
18 printf("\nswapping...\n");
19 tmp = s1;
20 s1 = s2;
21 s2 = tmp;
22
23 printf("\nafter swap: \n");
24 printf("s1: %s\n", s1);
25 printf("s2: %s\n", s2);
26
27 return 0;
28 }
运行截图：
代码一：
代码二：
问题回答：
代码一：
问题一：数组ｓ１的大小两个方面。一个是所占用字节数，一个是所包含的字符的个数。包括：
- 字母（大写和小写，例如 'A', 'b'）
- 数字（例如 '0', '1', '2' 等）
- 特殊字符（例如 '@', '#', '$', ' ', '!', 等）
- 空格（空格字符 ' ' 也会被计算在内）但是不包括＼０这个结束符标记。
sizeof(s1) 计算的是数组ｓ１所占用字节数，包括结束符＼０所占用的一个字节。 strlen(s1) 统计的是数组ｓ１所包含的字符的个数。
问题二：不可以这样书写。
报错：7 4 C:\Users\33918\OneDrive\桌面\task2_1.c [Error] assignment to expression with array type。
原因是：
字符数组如果单独写名称对应的其实是字符数组的首地址对应的常量指针。
正确方法是：char s1[N]; strcpy(s1, "Learning makes me happy");
或者直接初始化：
char s1[N] = "Learning makes me happy";
问题三：
交换了的。借用中间一个足够大的字符数组ｔｍｐ，利用ｓｔｒｃｐｙ的功能实现了交换位置。
代码二：
问题一：
s1中存放的是字符串常量“Learning makes me happy"的指针地址，是这个字符串的内存位置。
sizeof(s1)计算的是指针s1所占用的字节数，根据系统不一样，指针所占用的字节数大小也不一样，我的电脑上运行后，结果是4，说明我是32位的系统，在64位系统上的结果是8；
strlen(s1)统计的是s1所指向的内容的长度，不包含结束符。
问题二：可以的。这种方法是先为指针进行了声明，而后进行了对它所指向地址的赋值。
问题三：执行的交换操作是指针变量 s1和 s2 的值，即它们各自指向的内存地址.字符串本身在内存中的位置并没有交换，仍处于原来的位置。
3. 实验任务3
代码：
1 #include <stdio.h>
2
3 int main() {
4 int x[2][4] = {{1, 9, 8, 4}, {2, 0, 4, 9}};
5 int i, j;
6 int *ptr1; // 指针变量，存放int类型数据的地址
7 int(*ptr2)[4]; // 指针变量，指向包含4个int元素的一维数组
8
9 printf("输出1: 使用数组名、下标直接访问二维数组元素\n");
10 for (i = 0; i < 2; ++i) {
11 for (j = 0; j < 4; ++j)
12 printf("%d ", x[i][j]);
13 printf("\n");
14 }
15
16 printf("\n输出2: 使用指针变量ptr1(指向元素)间接访问\n");
17 for (ptr1 = &x[0][0], i = 0; ptr1 < &x[0][0] + 8; ++ptr1, ++i) {
18 printf("%d ", *ptr1);
19
20 if ((i + 1) % 4 == 0)
21 printf("\n");
22 }
23
24 printf("\n输出3: 使用指针变量ptr2(指向一维数组)间接访问\n");
25 for (ptr2 = x; ptr2 < x + 2; ++ptr2) {
26 for (j = 0; j < 4; ++j)
27 printf("%d ", *(*ptr2 + j));
28 printf("\n");
29 }
30
31 return 0;
32 }
运行截图：
4. 实验任务4
代码
1 #include <stdio.h>
2 #define N 80
3
4 void replace(char *str, char old_char, char new_char); // 函数声明
5
6 int main() {
7 char text[N] = "Programming is difficult or not, it is a question.";
8
9 printf("原始文本: \n");
10 printf("%s\n", text);
11
12 replace(text, 'i', '*'); // 函数调用 注意字符形参写法，单引号不能少
13
14 printf("处理后文本: \n");
15 printf("%s\n", text);
16
17 return 0;
18 }
19
20 // 函数定义
21 void replace(char *str, char old_char, char new_char) {
22 int i;
23
24 while(*str) {
25 if(*str == old_char)
26 *str = new_char;
27 str++;
28 }
29 }
运行截图：
问题回答：
1，replace可以指定将指针指向的字符数组当中的特定字符替换成另一种字符。
2，可以的。字符数组最后系统自动加上一处结束符标记\0当系统读取到这个字符结束标记也意味着循环结束，指针不再后移，完成了所有对应字符的替换。
5. 实验任务5
代码：
1 #include <stdio.h>
2 #define N 80
3
4 char *str_trunc(char *str, char x);
5
6 int main() {
7 char str[N];
8 char ch;
9
10 while(printf("输入字符串: "), gets(str) != NULL) {
11 printf("输入一个字符: ");
12 ch = getchar();
13
14 printf("截断处理...\n");
15 str_trunc(str, ch); // 函数调用
16
17 printf("截断处理后的字符串: %s\n\n", str);
18 getchar();
19 }
20
21 return 0;
22 }
23 char *str_trunc(char *str, char x){
24 char *p = str;
25
26 while (*p) {
27 if (*p == x) {
28 *p = '\0';
29 break;
30 }
31 p++;
32 }
33
34 return str;
35 }
运行截图：
问题回答：
去掉getchar()之后，多组运行结果如上图所示，结果无法正确读取输入。
下一次输入前缓冲区中的换行符没有用getchar()实现清除，导致下次输入直接读取了换行符，造成错误产生。
6. 实验任务6
代码：
1 #include <stdio.h>
2 #include <string.h>
3 #include <ctype.h>
4 #define N 5
5
6 int check_id(char *str); // 函数声明
7
8 int main()
9 {
10 char *pid[N] = {"31010120000721656X",
11 "3301061996X0203301",
12 "53010220051126571",
13 "510104199211197977",
14 "53010220051126133Y"};
15 int i;
16
17 for (i = 0; i < N; ++i)
18 if (check_id(pid[i])) // 函数调用
19 printf("%s\tTrue\n", pid[i]);
20 else
21 printf("%s\tFalse\n", pid[i]);
22
23 return 0;
24 }
25 int check_id(char *str){
26 int i;
27 char m=str[17];
28 if(strlen(str)!=18) return 0;
29
30
31
32
33
34 for(i=0;i<17;i++){
35 if(!isdigit(str[i])){
36 return 0;
37 }
38 }
39
40
41 if(m!='x'&&m!='X'&& !isdigit(m)){
42 return 0;
43 }
44
45 return 1;
46 }
运行截图：
7. 实验任务7
代码：
1 #include <stdio.h>
2 #define N 80
3 void encoder(char *str, int n); // 函数声明
4 void decoder(char *str, int n); // 函数声明
5
6 int main() {
7 char words[N];
8 int n;
9 while(printf("输入英文文本:" ), gets(words) != NULL) {//多组输入
10
11
12
13 printf("输入n: ");
14 scanf("%d", &n);
15
16 printf("编码后的英文文本: ");
17 encoder(words, n); // 函数调用
18 printf("%s\n", words);
19
20 printf("对编码后的英文文本解码: ");
21 decoder(words, n); // 函数调用
22 printf("%s\n", words);
23
24
25 getchar();//清空缓冲区当中的回车符
26
27 printf("\n");}
28 return 0;
29 }
30
31 /*函数定义
32 功能：对s指向的字符串进行编码处理
33 编码规则：
34 对于a~z或A~Z之间的字母字符，用其后第n个字符替换; 其它非字母字符，保持不变
35 */
36 void encoder(char *str, int n) {
37
38 while (*str) {
39 if (*str >= 'a' && *str <= 'z') {
40 *str = ((*str - 'a' + n) % 26) + 'a'; // 循环处理小写字母
41 } else if (*str >= 'A' && *str <= 'Z') {
42 *str = ((*str - 'A' + n) % 26) + 'A'; // 循环处理大写字母
43 }
44 str++; // 移动到下一个字符
45 }
46
47 }
48
49 /*函数定义
50 功能：对s指向的字符串进行解码处理
51 解码规则：
52 对于a~z或A~Z之间的字母字符，用其前面第n个字符替换; 其它非字母字符，保持不变
53 */
54 void decoder(char *str, int n) {
55 while (*str) {
56 if (*str >= 'a' && *str <= 'z') {
57 *str = ((*str - 'a' - n+26) % 26) + 'a'; // 循环处理小写字母
58 } else if (*str >= 'A' && *str <= 'Z') {
59 *str = ((*str - 'A' - n+26) % 26) + 'A'; // 循环处理大写字母
60 }
61 str++; // 移动到下一个字符
62 }
63
64 }
运行截图：
8. 实验任务8
代码：
运行截图：
问题回答：
四、实验结论
1. 实验任务1
2. 实验任务2
3. 实验任务3
4. 实验任务4
5. 实验任务5
6. 实验任务6
7. 实验任务7
8. 实验任务8
五、实验总结（选）
标签：int,s1,编程,C语言,char,str,printf,指针 From： https://www.cnblogs.com/andongni51/p/18580816