实验任务1
task1_1
1 #include <stdio.h>
2 #define N 4
3
4 void test1() {
5 int a[N] = {1, 9, 8, 4};
6 int i;
7
8 // 输出数组a占用的内存字节数
9 printf("sizeof(a) = %d\n", sizeof(a));
10
11 // 输出int类型数组a中每个元素的地址、值
12 for (i = 0; i < N; ++i)
13 printf("%p: %d\n", &a[i], a[i]);
14
15 // 输出数组名a对应的值
16 printf("a = %p\n", a);
17 }
18
19 void test2() {
20 char b[N] = {'1', '9', '8', '4'};
21 int i;
22
23 // 输出数组b占用的内存字节数
24 printf("sizeof(b) = %d\n", sizeof(b));
25
26 // 输出char类型数组b中每个元素的地址、值
27 for (i = 0; i < N; ++i)
28 printf("%p: %c\n", &b[i], b[i]);
29
30 // 输出数组名b对应的值
31 printf("b = %p\n", b);
32 }
33
34 int main() {
35 printf("测试1: int类型一维数组\n");
36 test1();
37
38 printf("\n测试2: char类型一维数组\n");
39 test2();
40
41 return 0;
42 }
1.int型数组a在内存中是连续存放的，每个元素占用4个内存字节单元，数组名a对应的值和&a[0]是一样的。
2.char型数组b在内存中是连续存放的，每个元素占用4个内存字节单元，数组名b对应的值和&b[0]是一样的。
task1_2
1 #include <stdio.h>
2 #define N 2
3 #define M 4
4
5 void test1() {
6 int a[N][M] = {{1, 9, 8, 4}, {2, 0, 4, 9}};
7 int i, j;
8
9 // 输出int类型二维数组a占用的内存字节数
10 printf("sizeof(a) = %d\n", sizeof(a));
11
12 // 输出int类型二维数组a中每个元素的地址、值
13 for (i = 0; i < N; ++i)
14 for (j = 0; j < M; ++j)
15 printf("%p: %d\n", &a[i][j], a[i][j]);
16 printf("\n");
17
18 // 输出int类型二维数组名a, 以及，a[0], a[1]的值
19 printf("a = %p\n", a);
20 printf("a[0] = %p\n", a[0]);
21 printf("a[1] = %p\n", a[1]);
22 printf("\n");
23 }
24
25 void test2() {
26 char b[N][M] = {{'1', '9', '8', '4'}, {'2', '0', '4', '9'}};
27 int i, j;
28
29 // 输出char类型二维数组b占用的内存字节数
30 printf("sizeof(b) = %d\n", sizeof(b));
31
32 // 输出char类型二维数组b中每个元素的地址、值
33 for (i = 0; i < N; ++i)
34 for (j = 0; j < M; ++j)
35 printf("%p: %c\n", &b[i][j], b[i][j]);
36 printf("\n");
37
38 // 输出char类型二维数组名b, 以及，b[0], b[1]的值
39 printf("b = %p\n", b);
40 printf("b[0] = %p\n", b[0]);
41 printf("b[1] = %p\n", b[1]);
42 }
43
44 int main() {
45 printf("测试1: int型两维数组");
46 test1();
47
48 printf("\n测试2: char型两维数组");
49 test2();
50
51 return 0;
52 }
实验任务2
1 #include <stdio.h>
2 #include <string.h>
3
4 #define N 80
5
6 void swap_str(char s1[], char s2[]);
7 void test1();
8 void test2();
9
10 int main() {
11 printf("测试1: 用两个一维char数组，实现两个字符串交换\n");
12 test1();
13
14 printf("\n测试2: 用二维char数组，实现两个字符串交换\n");
15 test2();
16
17 return 0;
18 }
19
20 void test1() {
21 char views1[N] = "hey, C, I hate u.";
22 char views2[N] = "hey, C, I love u.";
23
24 printf("交换前: \n");
25 puts(views1);
26 puts(views2);
27
28 swap_str(views1, views2);
29
30 printf("交换后: \n");
31 puts(views1);
32 puts(views2);
33 }
34
35 void test2() {
36 char views[2][N] = {"hey, C, I hate u.",
37 "hey, C, I love u."};
38
39 printf("交换前: \n");
40 puts(views[0]);
41 puts(views[1]);
42
43 swap_str(views[0], views[1]);
44
45 printf("交换后: \n");
46 puts(views[0]);
47 puts(views[1]);
48 }
49
50 void swap_str(char s1[N], char s2[N]) {
51 char tmp[N];
52
53 strcpy(tmp, s1);
54 strcpy(s1, s2);
55 strcpy(s2, tmp);
56 }
对于一维字符数组而言，一维数组名本身就代表了数组首元素的地址，而一维数组名在函数参数中隐式转换为指向数组首元素的指针。在test1()中，views1和views2是一维字符数组，因此可以直接作为swap_str()函数的参数，无需加上方括号。而在test2()中，views是一个二维字符数组，views[0]和views[1]分别是一维字符数组，可以直接作为swap_str()函数的参数，但因为views是一个二维字符数组，其本身可以表示指向第一个元素（即第一行）的指针，但无法表示指向第二个元素的指针，所以它在test2()中调用时需要加上方括号。
总结：对于一维字符数组，可以直接使用数组名访问首元素；而对于二维字符数组，需使用数组名[X]访问第X个元素（即第X行）。
实验任务3
task3_1
1 /*
2 从键盘输入一行英文文本，统计英文单词总数
3 为了简化问题处理，只考虑单词以空格间隔的情形
4 对教材例5.22代码做了些微改动:
5 1. 统计单词个数，编写成函数模块；增加了多组输入
6 2. 去掉了不必要的中间变量
7 */
8
9 #include <stdio.h>
10
11 #define N 80
12
13 int count(char x[]);
14
15 int main() {
16 char words[N+1];
17 int n;
18
19 while(gets(words) != NULL) {
20 n = count(words);
21 printf("单词数: %d\n\n", n);
22 }
23
24 return 0;
25 }
26
27 int count(char x[]) {
28 int i;
29 int word_flag = 0; // 用作单词标志，一个新单词开始，值为1；单词结束，值为0
30 int cnt = 0; // 统计单词个数
31
32 for(i = 0; x[i] != '\0'; i++) {
33 if(x[i] == ' ')
34 word_flag = 0;
35 else if(word_flag == 0) {
36 word_flag = 1;
37 cnt++;
38 }
39 }
40
41 return cnt;
42 }
优化后代码：
1 #include <stdio.h>
2
3 #define N 80
4
5 int count(char x[]);
6
7 int main() {
8 char words[N+1];
9 int n;
10
11 while(gets(words) != NULL) {
12 n = count(words);
13 printf("单词数: %d\n\n", n);
14 }
15 return 0;
16 }
17
18 int count(char x[]) {
19 int i;
20 int word_flag = 0; // 用作单词标志，一个新单词开始，值为1；单词结束，值为0
21 int cnt = 0; // 统计单词个数
22
23 for(i = 0; x[i] != '\0'; i++) {
24 if(!(x[i] <= 'z' && x[i] >='A'))
25 word_flag = 0;
26 else if(word_flag == 0) {
27 word_flag = 1;
28 cnt++;
29 }
30 }
31
32 return cnt;
33 }
task3_2
1 /*
2 输入一行英文文本，统计最长单词，并打印输出。
3 为简化问题，只考虑单词之间用空格间隔的情形。
4 相较于教材例5.24，做了以下改动：
5 1. 增加了多组输入，因此，一些变量初始化放到了第一层循环里面
6 2. 微调了代码书写逻辑和顺序
7 */
8
9 #include <stdio.h>
10 #define N 1000
11
12 int main() {
13 char line[N];
14 int word_len; // 记录当前单词长度
15 int max_len; // 记录最长单词长度
16 int end; // 记录最长单词结束位置
17 int i;
18
19 while(gets(line) != NULL) {
20 word_len = 0;
21 max_len = 0;
22 end = 0;
23
24 i = 0;
25 while(1) {
26 // 跳过连续空格
27 while(line[i] == ' ') {
28 word_len = 0; // 单词长度置0，为新单词统计做准备
29 i++;
30 }
31
32 // 在一个单词中，统计当前单词长度
33 while(line[i] != '\0' && line[i] != ' ') {
34 word_len++;
35 i++;
36 }
37
38 // 更新更长单词长度，并，记录最长单词结束位置
39 if(max_len < word_len) {
40 max_len = word_len;
41 end = i; // end保存的是单词结束的下一个坐标位置
42 }
43
44 // 遍历到文本结束时，终止循环
45 if(line[i] == '\0')
46 break;
47 }
48
49 // 输出最长单词
50 printf("最长单词: ");
51 for(i = end - max_len; i < end; ++i)
52 printf("%c", line[i]);
53 printf("\n\n");
54 }
55
56 return 0;
57 }
优化后：
1 #include <stdio.h>
2 #define N 1000
3
4 int main() {
5 char line[N];
6 int word_len; // 记录当前单词长度
7 int max_len; // 记录最长单词长度
8 int end; // 记录最长单词结束位置
9 int i;
10
11 while(gets(line) != NULL) {
12 word_len = 0;
13 max_len = 0;
14 end = 0;
15
16 i = 0;
17 while(1) {
18 // 跳过连续空格
19 while(!(line[i] <= 'z' && line[i] >='A')) {
20 word_len = 0; // 单词长度置0，为新单词统计做准备
21 i++;
22 }
23
24 // 在一个单词中，统计当前单词长度
25 while(line[i] <= 'z' && line[i] >= 'A') {
26 word_len++;
27 i++;
28 }
29
30 // 更新更长单词长度，并，记录最长单词结束位置
31 if(max_len < word_len) {
32 max_len = word_len;
33 end = i; // end保存的是单词结束的下一个坐标位置
34 }
35
36 // 遍历到文本结束时，终止循环
37 if(line[i] == '\0')
38 break;
39 }
40
41 // 输出最长单词
42 printf("最长单词: ");
43 for(i = end - max_len; i < end; ++i)
44 printf("%c", line[i]);
45 printf("\n\n");
46 }
47 return 0;
48 }
实验任务4
1 #include <stdio.h>
2 #define N 100
3 void dec_to_n(int x, int n); // 函数声明
4
5 int main() {
6 int x;
7
8 printf("输入一个十进制整数: ");
9 while(scanf("%d", &x) != EOF) {
10 dec_to_n(x, 2); // 函数调用: 把x转换成二进制输出
11 dec_to_n(x, 8); // 函数调用: 把x转换成八进制输出
12 dec_to_n(x, 16); // 函数调用: 把x转换成十六进制输出
13
14 printf("\n输入一个十进制整数: ");
15 }
16 return 0;
17 }
18
19 // 函数定义
20 // 功能: 把十进制数x转换成n进制，打印输出
21 // 补足函数实现
22 // ×××
23 void dec_to_n(int x, int n) {
24 char convert[N];
25 int i = 0,j;
26
27 while (x >= n) {
28 int num = x % n;
29 if (num >= 10) {
30 convert[i] = num - 10 + 'A';
31 } else {
32 convert[i] = num + '0';
33 }
34 x /= n;
35 i++;
36 }
37
38 if (x > 0) {
39 if (x >= 10) {
40 convert[i] = x - 10 + 'A';
41 } else {
42 convert[i] = x + '0';
43 }
44 i++;
45 }
46
47 for (j = i - 1; j >= 0; j--) {
48 printf("%c", convert[j]);
49 }
50 printf("\n");
51 }
实验任务5
1 #include <stdio.h>
2 #define N 5
3
4 // 函数声明
5 void input(int x[], int n);
6 void output(int x[], int n);
7 double average(int x[], int n);
8 void bubble_sort(int x[], int n);
9
10 int main() {
11 int scores[N];
12 double ave;
13
14 printf("录入%d个分数:\n", N);
15 input(scores, N);
16
17 printf("\n输出课程分数: \n");
18 output(scores, N);
19
20 printf("\n课程分数处理: 计算均分、排序...\n");
21 ave = average(scores, N);
22 bubble_sort(scores, N);
23
24 printf("\n输出课程均分: %.2f\n", ave);
25 printf("\n输出课程分数(高->低):\n");
26 output(scores, N);
27 return 0;
28 }
29
30 // 函数定义
31 // 输入n个整数保存到整型数组x中
32 void input(int x[], int n) {
33 int i;
34
35 for(i = 0; i < n; ++i)
36 scanf("%d", &x[i]);
37 }
38
39 // 输出整型数组x中n个元素
40 void output(int x[], int n) {
41 int i;
42
43 for(i = 0; i < n; ++i)
44 printf("%d ", x[i]);
45 printf("\n");
46 }
47
48 // 计算整型数组x中n个元素均值，并返回
49 // 补足函数average()实现
50 // ×××
51 double average(int x[], int n){
52 int i,ave,sum=0;
53 for(i = 0; i < n; i++)
54 sum += x[i];
55 ave = sum/n;
56 return ave;
57 }
58
59 // 对整型数组x中的n个元素降序排序
60 // 补足函数bubble_sort()实现
61 // ×××
62 void bubble_sort(int x[], int n){
63 int i,j;
64 for (i = 0; i < n - 1; i++) {
65 int flag = 0;
66 for (j = 0; j < n - i - 1; j++) {
67 if (x[j] < x[j + 1]) {
68 int temp = x[j];
69 x[j] = x[j + 1];
70 x[j + 1] = temp;
71 flag = 1;
72 }
73 }
74 if (!flag) {
75 break;
76 }
77 }
78 }
实验任务6
1 #include <stdio.h>
2 #include <string.h>
3
4 #define N 5
5 #define M 20
6
7 // 函数声明
8 void output(char str[][M], int n);
9 void bubble_sort(char str[][M], int n);
10
11 int main() {
12 char name[][M] = {"Bob", "Bill", "Joseph", "Taylor", "George"};
13 int i;
14
15 printf("输出初始名单:\n");
16 output(name, N);
17
18 printf("\n排序中...\n");
19 bubble_sort(name, N); // 函数调用
20
21 printf("\n按字典序输出名单:\n");
22 output(name, N);
23 return 0;
24 }
25
26 // 函数定义
27 // 功能：按行输出二维数组中的字符串
28 void output(char str[][M], int n) {
29 int i;
30
31 for(i = 0; i < n; ++i)
32 printf("%s\n", str[i]);
33 }
34
35 // 函数定义
36 // 功能：使用冒泡排序算法对二维数组str中的n个字符串按字典序排序
37 // 补足函数bubble_sort()实现
38 // ×××
39 void bubble_sort(char str[][M], int n){
40 int i, j;
41 char tmp[M];
42
43 for(i = 0; i < n-1; ++i) {
44 for(j = 0; j < n-i-1; ++j) {
45 if(strcmp(str[j], str[j+1]) > 0) {
46 strcpy(tmp, str[j]);
47 strcpy(str[j], str[j+1]);
48 strcpy(str[j+1], tmp);
49 }
50 }
51 }
52 }
实验任务7
1 #include <stdio.h>
2 #define N 101
3
4 int is_repeat(char x[]);
5
6 int main() {
7 char num[N];
8
9 while(scanf("%s",num)!= EOF){
10 if(is_repeat(num))
11 printf("YES\n\n");
12 else
13 printf("NO\n\n");
14 }
15
16 return 0;
17 }
18
19 int is_repeat(char x[]){
20 int cnt[10] = {0};
21 int i,j;
22
23 for(i = 0;x[i] != '\0';++i){
24 j = x[i] - '0';
25 cnt[j]++;
26 if(cnt[j] > 1)
27 return 1;
28 }
29
30 return 0;
31 }
实验任务8
1 #include <stdio.h>
2 #define N 100
3 #define M 4
4
5 // 函数声明
6 void output(int x[][N], int n);
7 void rotate_to_right(int x[][N], int n);
8
9
10 int main() {
11 int t[][N] = {{21, 12, 13, 24},
12 {25, 16, 47, 38},
13 {29, 11, 32, 54},
14 {42, 21, 33, 10}};
15
16 printf("原始矩阵:\n");
17 output(t, M); // 函数调用
18
19 rotate_to_right(t, M); // 函数调用
20
21 printf("变换后矩阵:\n");
22 output(t, M); // 函数调用
23
24 return 0;
25 }
26
27 // 函数定义
28 // 功能: 输出一个n*n的矩阵x
29 void output(int x[][N], int n) {
30 int i, j;
31
32 for (i = 0; i < n; ++i) {
33 for (j = 0; j < n; ++j)
34 printf("%4d", x[i][j]);
35
36 printf("\n");
37 }
38 }
39
40 // 待补足3：函数rotate_to_right()定义
41 // 功能: 把一个n*n的矩阵x，每一列向右移, 最右边被移出去的一列绕回左边
42 // xxx
43 void rotate_to_right(int x[][N], int n){
44 int i,j;
45 int y[N];
46
47 for (i = 0; i < n; ++i)
48 y[i] = x[i][n - 1];
49 for (i = n - 1; i > 0; --i)
50 for (j = 0; j < n; ++j)
51 x[j][i] = x[j][i-1];
52 for (i = 0; i < n; ++i)
53 x[i][0] = y[i];
54 }
实验总结
- 对于字符数组的处理不够熟练，在访问和遍历的时候容易出现问题，还需多加练习；
- 实验任务4和实验任务7学习到了对整数串的处理方式，遇到数值较大超出数据类型范围的数值可考虑采用字符串处理；
- 数学模型和代码之间的转化能力不足，有时候难以用代码实现自己构建的数学模型，还有很大进步空间。
标签：单词,int,void,编程,C语言,char,++,数组,printf From： https://www.cnblogs.com/silverbullet4869/p/18188185