选择题
[1] 下列叙述中正确的是().
A. 算法的时间复杂度是指算法在执行过程中基本运算的次数
B. 算法的时间复杂度是指算法执行所需要的时间
C. 算法的时间复杂度是指算法执行的速度
D. 算法复杂度是指算法控制结构的复杂程度
参考答案: A
算法的时间复杂度是指执行算法所需要的计算工作量, 其计算工作量是用算法所执行的基本运算次数来度量的.
[2] 下列叙述中正确的是().
A. 循环队列是队列的一种链式存储结构
B. 循环队列是队列的一种顺序存储结构
C. 循环队列中的队尾指针一定大于队头指针
D. 循环队列中的队尾指针一定小于队头指针
参考答案: B
在实际应用中, 队列的顺序存储结构一般采用循环队列的形式. 当循环队列满或者为空时: 队尾指针 = 队头指针.
[3] 某完全二叉树有 256 个结点, 则该二叉树的深度为().
- A.7
- B.8
- C.9
- D.10
参考答案: C
根据完全二叉树的性质: 具有 n 个结点的完全二叉树的深度为[log 2 n] + 1. 本题中完全二叉树共有 256 个结点, 则深度为[log 2 256 ] + 1 = 8 + 1 = 9.
[4] 下列叙述中错误的是().
A. 线性结构也能采用链式存储结构
B. 线性结构一定能采用顺序存储结构
C. 有的非线性结构也能采用顺序存储结构
D. 非线性结构一定不能采用顺序存储结构
参考答案: D
满二叉树与完全二叉树均为非线性结构, 但可以按照层次进行顺序存储.
[5] 需求分析的主要任务是().
A. 确定软件系统的功能
B. 确定软件开发方法
C. 确定软件开发工具
D. 确定软件开发人员
参考答案: A
需求分析是软件开发之前必须要做的准备工作之一. 需求是指用户对目标软件系统在功能, 行为, 性能, 设计约束等方面的期望. 故需求分析的主要任务是确定软件系统的功能.
[6] 一个模块直接调用的下层模块的数目称为模块的().
A. 扇入数
B. 扇出数
C. 宽度
D. 作用域
参考答案: B
扇入数指调用一个给定模块的模块个数. 扇出数是指由一个模块直接调用的其他模块数, 即一个模块直接调用的下层模块的数目.
[7] 将数据和操作置于对象统一体中的实现方式是().
A. 隐藏
B. 抽象
C. 封装
D. 结合
参考答案: C
对象具有封装性, 从外面看只能看到对象的外部特性, 对象的内部对外是封闭的. 即封装实现了将数据和操作置于对象统一体中.
[8] 采用表结构来表示数据及数据间联系的模型是().
A. 层次模型
B. 概念模型
C. 网状模型
D. 关系模型
参考答案: D
关系模型采用二维表来表示, 简称表.
[9] 在供应关系中, 实体供应商和实体零件之间的联系是().
A. 多对多
B. 一对一
C. 多对一
D. 一对多
参考答案: A
一家供应商可提供多种零件, 一种零件也可被多家供应商提供. 所以实体供应商和实体零件之间的联系是多对多.
[10] 如果定义班级关系如下:
班级(班级号, 总人数, 所属学院, 班级学生)
则使它不满足第一范式的属性是().
A. 班级号
B. 班级学生
C. 总人数
D. 所属学院
参考答案: B
对于关系模式, 若其中的每个属性都已不能再分为简单项, 则它属于第一范式模式. 题目中 "班级" 关系的 "班级学生" 属性, 还可以进行再分, 如学号, 姓名, 性别, 出生日期等, 因此不满足第一范式.
[11] 以下说法正确的是().
A.C 语言只接受十进制的数
B.C 语言只接受八进制, 十进制, 十六进制的数
C.C 语言接受除二进制之外任何进制的数
D.C 语言接受任何进制的数
参考答案: B
C 可以使用格式控制符 %d, %u, %f 等接受十进制的数, 使用 %o 接受八进制的数, 使用 %x 接受十六进制的数, 本题答案选 B.
[12] 以下说法错误的是().
A. 由三种基本结构组成的结构化程序不能解决过于复杂的问题
B. 由三种基本结构组成的结构化程序能解决一些简单的问题
C. 由三种基本结构组成的结构化程序能解决递归问题
D. 由三种基本结构组成的结构化程序能解决数学上有解析解的问题
参考答案: A
顺序结构, 选择结构, 循环结构是三种基本结构, 由三种基本结构所构成的程序称为结构化程序, 由三种基本结构组成的算法可以解决任何复杂的问题, 选项 A 错误, 本题答案 A
[13] 以下说法错误的是().
A.C 语言标识符中可以有多个字母, 数字和下划线字符
B.C 语言标识符中下划线字符可以出现在任意位置
C.C 语言标识符不能全部由数字组成
D.C 语言标识符必须以字母开头
参考答案: D
C 语言的合法的标识符的命名规则是: 标识符可以由字母, 数字和下划线组成, 并且第一个字符必须是字母或下划线. 选项 D 错误, 本题答案 D
[14] 以下说法错误的是().
A.C 语言中的常量是指在程序运行过程中经常被用到的变量
B.C 语言中的常量是指在程序运行过程中其值不能被改变的量
C.C 语言中的常量可以用一个符号名来代表
D.C 语言中的常量可以用宏来定义
参考答案: A
C 语言中的常量是指在程序运行过程中其值不能被改变的量, 它可以用宏来定义, 用一个符号名代表, 选项 A 错误, 选项 B,C,D 正确, 本题答案 A
[15] 若有定义: int a = 1234, b = -5678; 用语句 printf("%+-6d%+-6d", a, b); 输出, 以下正确的输出结果是().
- A.+1234 -5678(中间有一个空格, 最后有一个空格)
- B. +1234 -5678(最前面有一个空格, 中间有一个空格)
- C.+-1234+-5678(最前面和最后均无空格)
- D.1234 -5678 (中间有两个空格, 最后有一个空格)
参考答案: A
printf 函数参数包括格式控制字符串和输出参数, 其中格式控制字符串中除了格式控制字符外, 其他字符原样输出, 本题中, 在 % 和格式字符 d 之间, + 号表示输出的数字带正负号, - 号表示输出数据向左对齐, 6 表示表示输出宽度, 如果输出数据的宽度不够 6, 那么左对齐, 右边补空格, 所以本题输出 + 1234 - 5678 ,
中间一个空格, 最后一个空格, 本题答案 A
[16] 若有定义: double a; float b; short c;
若想把 1.2 输入给变量 a,3.4 输入给变量 b,5678 输入给变量 c, 程序运行时键盘输入:
1.2 3.4 5678 <回车>
则以下正确的读入语句是().
- A.scanf("%lf%lf%d", &a, &b, &c);
- B.scanf("%lf%lf%hd", &a, &b, &c);
- C.scanf("%lf%f%hd", &a, &b, &c);
- D.scanf("%f%f%d", &a, &b, &c);
参考答案: C
scanf 函数用于输入数据, 第一个参数表示输入格式控制, 本题变量 a 是 double 类型, 使用格式控制符 %lf, 变量 b 是 float 类型, 使用 %f, 变量 c 是 short 类型, 使用 %hd, 选项 C 正确, 本题答案 C
[17] 有下列程序
- #include <stdio.h>
- void main()
- {
- int a = 1, b = 1, c = 1;
- if (a-- || b-- && --c)
- printf("%d,%d,%d\n", a, b, c);
- else
- printf("%d,%d,%d\n", a, c, b);
- }
程序执行后的输出结果是() .
- A.0, 1, 0
- B.0, 1, 1
- C.0, 0, 1
- D.0, 0, 0
参考答案: B
if 条件表达式 a-- || b-- && --c 使用了逻辑或运算符和逻辑与运算符, 由于逻辑与运算符优先级比逻辑或运算符优先级高, 所以条件表达式等价于(a--) || (b-- && --c), 自左向右运算, 执行 a--, 由于 a 初值为 1, 所以 a-- 的值为 1, 执行完后 a 的值为 0; 又因为逻辑或运算符的短路原则, 当 a-- 的值为 1 时, 条件为真, 后面的表达式 b-- && --c 不执行, 程序执行 if 语句块, 输出 a,b,c 的值为: 0,1,1, 本题答案 B
[18] 有下列程序
- #include <stdio.h>
- void main()
- {
- int a = 123456, b;
- while (a)
- {
- b = a % 10;
- a /= 10;
- switch (b)
- {
- default: printf("%d", b++);
- case 1: break;
- case 2: printf("%d", b++); break;
- case 3: printf("%d", b++);
- case 4: printf("%d", b++);
- case 5: printf("%d", b++);
- }
- }
- }
程序执行后的输出结果是() .
- A.654321
- B.65432
- C.65453452
- D.654534521
参考答案: C
程序首先定义整型变量 a 和 b,a 的初值为 123456, 接着通过 while 循环, 判断 a 的值是否为 0, 若不为 0, 则执行循环体, 每次循环将 a 当前值的个位数字 (a % 10) 赋给 b,a 自身除以 10, 再通过 switch 语句判断 b 的值执行对应分支语句; 所以对于 a 的每个个位数, b 的取值为 6, 5, 4, 3, 2, 1, 当 b 取值为 6 时, 执行 default,
输出 6, 接着继续执行 case 1,break 退出 switch, 执行下一次循环; 当 b 取值为 5 时, 执行 case 5 输出 5, 执行下一次循环; 当 b 取值为 4 时, 执行 case 4 输出 4, 继续
执行 case 5 输出 5, 接着下一次循环; 当 b 取值为 3 时, 执行 case 3 输出 3, 执行 case 4 输出 4, 执行 case 5 输出 5; 当 b 取值为 2 时, 执行 case 2 输出 2,break 跳出
switch; 当 b 取值为 1 时, 执行 break, 此时 a 的取值为 0, 循环终止, 程序输出结果为: 65453452, 本题答案 C.
[19] 有下列程序
- #include <stdio.h>
- void main()
- {
- int a = 1, b = -2;
- for (; a-- && b++;)
- printf("%d,%d,", a, b);
- printf("%d,%d", a, b);
- }
程序执行后的输出结果是() .
- A.0,-1,-1,-1
- B.0,-1,-1,0
- C.0,-1,-1,0,-1,0
- D.0,-1,-1,-1,-1,-1
参考答案: A
程序定义整型变量 a 和 b, 初值分别是 1,-2,for 语句中循环条件式为 a-- && b++, 由于 -- 和 ++ 的优先级高于逻辑与运算符 && , 所以等价于(a--) && (b++), 自左向右运算
第一轮循环, a,b 的值为 1, -2: 首先执行 a--,a-- 的值为 1, 执行完后 a 的值为 0, 继续执行 b++,b++ 的值为 - 2, 执行完后 b 的值为 - 1, 整个表达式 a-- && b++ 的值为真, 程序输出 0, - 1; 接着继续循环第二轮循环, a,b 的值为 0, - 1: 首先执行 a--,a-- 的值为 0, 执行完后 a 的值为 - 1, 由于 a-- 的值为 0, 逻辑与运算的短路原则, 表达式 a-- && b++ 的值一定为假, 表达式 b++ 不再执行, 循环结束, 执行循环体外的 printf 语句, 输出 a,b 的值分别为: - 1, - 1
所以本题输出结果为: 0, - 1, - 1, - 1, 本题答案 A
[20] 有下列程序
- #include <stdio.h>
- void main()
- {
- int a = 7, i;
- for (i = 1; i <= 3; i++)
- {
- if (a> 14) break;
- if (a % 2) { a += 3; continue; }
- a = a + 4;
- printf("%d,%d,", i, a);
- }
- printf("%d,%d", i, a);
- }
程序执行后的输出结果是() .
- A.2,14,3,18,4,18
- B.1,14,2,18,3,18
- C.2,14,3,18,4,22
- D.1,14,2,18,3,18,4,18
参考答案: A
程序定义整型变量 a 和 i, 其中 a 的初值为 7,for 循环中, 循环变量 i 的取值为 1, 2, 3, 循环体中判断 a 的取值, 当 a> 14 时, break 跳出循环; 当 a 取值为奇数时, a % 2 == 1,a 自增 3,continue 继续执行循环体; 当 a 取值为偶数时, a % 2 == 0,a 自增 4, 输出 i 和 a 的值; 所以:
i 取值为 1 时, a 取值为 7, 自增 3 后 a 的值为 10, 执行下一个循环
i 取值为 2 时, a 取值为 10, 自增 4 后 a 的值为 14, 输出 2, 14
i 取值为 3 时, a 取值为 14, 自增 4 后 a 的值为 18, 输出 3, 18
i 取值为 4 时, a 取值为 18, 循环终止, 输出 4, 18
综上, 程序输出: 2, 14, 3, 18, 4, 18, 本题答案为 A
[21] 以下正确的字符常量是().
- A.'\089'
- B.'\012'
- C.'\0XAB'
- D.'\0xab'
参考答案: B
题意中都以转义字符 \ 开头,\ 开头的转义字符中,\ddd 表示三位八进制数代表的一个 ASCII 字符,\xhh 表示二位十六进制数代表的一个 ASCII 字符; 选项 A 中 089 是不合法的八进制数, 错误; 选项 C,D 中 \ 0X 或 \ 0x 不合法, 错误; 选项 B 表示八进制数 012 代表的 ASCII 字符, 正确; 本题答案 B
[22] 有下列程序
- #include <stdio.h>
- void main()
- {
- char b[] = "happychristmas", k;
- for (k = 0; b[k]; k++)
- {
- if (b[k] <'m')
- b[k] = b[k] - 'a' + 'A';
- printf("%c", b[k]);
- }
- }
程序执行后的输出结果是() .
- A.hAppychristmAs
- B.happychristmas
- C.HAppyCHrIstmAs
- D.HAPPYCHRISTMAS
参考答案: C
程序定义一个字符数组 b, 和一个字符变量 k,for 循环通过循环变量 k, 遍历数组 b 中的各个字符, 通过 if 语句判断当前下标为 k 的字符的 ASCII 码与字符'm'的大小, 把数组 b 中 ASCII 码小于'm'的字符改成大写字母(b[k] = b[k] - 'a' + 'A'), 然后输出 b[k], 对于字符串 happychristmas,ASCII 码小于'm'的字符有: h, a, c, h, i, a, 所以
程序输出: HappyCHrIstmAs, 本题答案 C
[23] 有如下形式的函数
- int fun(int a[4][5], int *p[10], int n)
- {
- ......
- }
调用函数之前需要对函数进行说明, 即所谓的函数向前引用说明, 以下对 fun 函数说明正确的是().
- A.int fun(int b[][5], int *r[], int m);
- B.int fun(int a[4][], int *p[10], int n);
- C.int fun(int a[][], int *p[], int n);
- D.int fun(int a[], int *p[], int n);
参考答案: A
题意中函数的定义指出了函数名为 fun, 返回值为 int, 函数包含三个参数, 第一个参数是整型的二维数组, 第二个参数是整型数组, 第三个参数是整型变量, 在定义二维数组时, 必须指定第二维的长度, 所以选项 B,C,D 错误, 选项 A 正确, 本题答案 A
[24] 关于指针, 以下说法正确的是().
A. 可以直接向指针中写入数据
B. 若指针指向变量, 则可以向指针所指内存单元写入数据
C. 指针可以指向内存中任何位置, 并写入数据
D. 两个指针可以通过加运算求和, 形成一个功能更强大的指针
参考答案: B
C 语言中指针就是变量的地址, 它必须有确定的基类型, 当指针指向某个变量时, 才能向其中写入数据, 选项 A 错误, 选项 B 正确; 指针除了指向变量外, 还可以赋值为 NULL, 表示未指向任何地址, 此时不能写入数据, 另外指针必须有基类型, 只能指向基类型相同的变量, 选项 C 错误; 指针只能与一个整数进行运
算, 即移动指针, 两个指针不能运算, 选项 D 错误, 本题答案 B
[25] 有下列程序
- #include <stdio.h>
- int *f(int *s)
- {
- s += 1;
- s[1] += 6;
- *s-- += 7;
- return s;
- }
- void main()
- {
- int a[5] = { 1, 2, 3, 4, 5 }, *p;
- p = f(a);
- printf("%d,%d,%d,%d", a[1], a[2], *p, p[1]);
- }
程序执行后的输出结果是() .
- A.2,3,1,2
- B.9,9,2,9
- C.8,10,2,8
- D.9,9,1,9
参考答案: D
程序定义了一个整型数组 a, 它包含 5 个整型元素, 分别是 1, 2, 3, 4, 5, 此时 a 代表数组的首地址, 另外还定义整型指针 p, 将 a 传给函数 f, 在函数 f 中, 首先将指针 s 向右移动一个整型变量的长度, 此时 s 指向元素 2(a[1]),s[1](a[2])表示元素 3, 自增 6 后 s[1](a[2])的值为 9, 表达式 * s-- += 7 表示将 *(s--)指向的元素自增 7, 即 s[0](a[1])的值为 9,s 向左移动一个整型变量的长度, 此时 s 指向元素 1(a[0]), 最后将 s 返回赋给 p, 经过函数 f 的调用可知: p 指向数组 a 的第一个元素, a[1]和 a[2]值为 9, 综上, 输出结果为: 9, 9, 1, 9, 本题答案 D
[26] 有下列程序
- #include <stdio.h>
- void swap(int *a, int *b)
- {
- int *tp, t;
- t = *a; *a = *b; *b = t;
- tp = a; a = b; b = tp;
- printf("%d,%d,", *a, *b);
- }
- void main()
- {
- int i = 3, j = 7, *p = &i, *q = &j;
- swap(&i, &j);
- printf("%d,%d", *p, *q);
- }
程序执行后的输出结果是() .
A.3, 7, 3, 7
B.7, 3, 7, 3
C.3, 7, 7, 3
D.7, 3, 3, 7
参考答案: C
程序定义两个整型变量 i,j, 初值为 3, 7, 另外定义两个整型指针变量 p,q, 其中 p 指向 i,q 指向 j, 将 i,j 的地址传给 swap 函数, 在 swap 函数中, a 指向 i,b 指向 j, 通过临时变量 t 交换 a 和 b 指向的值, 此时 a 指向的实参 i,b 指向的实参 j 的值发生了交换, 即 a 指向 i 的值为 7,b 指向 j 的值为 3; 再通过临时变量 tp 交换 a 和 b 的指
针值, 使得 a 指向 j,b 指向 i, 所以 swap 中输出 a 指向的值为 3(j),b 指向的值为 7(i);swap 函数调用结束后, 输出 p 和 q 指向的值, 即 i,j 的值 7, 3, 所以程序输
出: 3,7, 7, 3, 本题答案 C
[27] 有下列程序
- #include <stdio.h>
- #define N 4
- int fun(int a[][N])
- {
- int i, y = 0;
- for (i = 0; i <N; i++)
- y += a[i][0] + a[i][N - 1];
- for (i = 1; i < N - 1; i++)
- y += a[0][i] + a[N - 1][i];
- return y;
- }
- void main()
- {
- int y, x[N][N] = {
- {1, 2, 3, 4 },
- {2, 1, 4, 3 },
- {3, 4, 1, 2 },
- {4, 3, 2, 1 }};
- y = fun(x);
- printf("%d", y);
- }
程序执行后的输出结果是() .
- A.30
- B.35
- C.40
- D.32
参考答案: A
程序定义一个整型变量 y 和整型二维数组 x, 并对 x 赋初值, 接着调用函数 fun, 在函数 fun 中, 第一个 for 循环将数组 a 的第 0 列和第 N - 1 列的所有元素累加到 y 中, 第二个 for 循环将数组 a 的第 0 行的 2, 3 和第 N - 1 行的 3, 2 累加到 y 中, 再将 y 返回, 所以 fun 函数的功能是将数组 a 的行列下标为 0,N - 1 的所有元素累加起来, 即
1, 2, 3, 4, 2, 3, 3, 2, 4, 3, 2, 1, 输出 30, 本题答案 A
[28] 有下列程序
- #include <stdio.h>
- void fun(int a[ ], int n, int flag)
- {
- int i = 0, j, t;
- for (i = 0; i <n - 1; i++)
- for (j = i + 1; j < n; j++)
- if (flag ? (a[i] < a[j]) :(a[i]> a[j]))
- { t = a[i]; a[i] = a[j]; a[j] = t; }
- }
- void main()
- {
- int c[10] = { 7, 9, 10, 8, 3, 5, 1, 6, 2, 4 }, i;
- fun(c, 5, 1);
- fun(c + 5, 5, 0);
- for (i = 0; i <10; i++)
- printf("%d,", c[i]);
- }
程序执行后的输出结果是() .
A.3, 7, 8, 9, 10, 6, 5, 4, 2, 1,
B.10, 9, 8, 7, 3, 1, 2, 4, 5, 6,
C.10, 9, 8, 7, 6, 1, 2, 3, 4, 5,
D.1, 2, 3, 4, 5, 10, 9, 8, 7, 6,
参考答案: B
程序中函数 fun 的功能是将数组 a 的 n 个元素, 按照 flag 的值进行排序: 当 flag 为 0 时, 升序排列, 当 flag 为 1 时, 降序排列. main 函数中定义数组 c, 初始化 10 个元素的值, 第一次调用 fun,flag 为 1, 即将 c 的下标为 0 开始的 5 个元素降序排列, 第二次调用 fun,flag 为 0, 将 c 的下标为 5 开始的 5 个元素升序排列, 所以数组 c 的
元素为: 10, 9, 8, 7, 3, 1, 2, 4, 5, 6, 本题答案 B.
[29] 有下列程序
- #include <stdio.h>
- void main()
- {
- int i, j = 0;
- char a[] = "ab1b23c4d56ef7gh89i9j64k", b[100];
- for (i = 0; a[i]; i++)
- if (a[i] <'a' || a[i]> 'z')
- b[j++] = a[i];
- for (i = 0; a[i]; i++)
- if (a[i] <'0' || a[i]> '9')
- b[j++] = a[i];
- b[j] = '\0';
- printf("%s", b);
- }
程序执行后的输出结果是() .
- A.abbcdefghijk123456789964
- B.123456789964abbcdefghijk
- C.123445667899abbcdefghijk
- D.abbcdefghijk123445667899
参考答案: B
程序定义数组 a,b, 其中 a 使用小写字母和数字构成的字符串完成初始化; 第一个 for 循环将数组 a 中所有的非小写字母字符 (数字字符) 自左向右存放到 b 数组中, 第二个 for 循环将数组 a 中所有的非数字字符 (小写字母) 自左向右存放到 b 的后续单元中, 在所有字符后添加空字符, 输出 b, 此时 b 的值为:
123456789964abbcdefghijk, 本题答案 B
[30] 有下列程序
- #include <stdio.h>
- void main()
- {
- char v[4][10] = { "efg","abcd","mnopq","hijkl" }, *p[4], t;
- int i, j;
- for (i = 0; i <4; i++)
- p[i] = v[i];
- for (i = 0; i < 3; i++)
- for (j = i + 1; j < 4; j++)
- if (*p[i]> *p[j])
- { t = *p[i]; *p[i] = *p[j]; *p[j] = t; }
- for (i = 0; i <4; i++)
- printf("%s" , v[i]);
- }
程序执行后的输出结果是() .
- A.abcd efg hijkl mnopq
- B.afg ebcd hnopq mijkl
- C.efg abcd mnopq hijkl
- D.mijkl hnopq ebcd afg
参考答案: B
程序首先定义二维字符数组 v, 使用四个字符串初始化, 另外定义字符指针数组 p, 通过第一个 for 循环, 将 v 的四个字符串的首地址赋给 p, 第二个 for 循环通过两层内嵌循环将 p 中元素指向的字符串首字母进行排序交换, 规则是: 将指向的字符串的首字母字符按照字母表中的顺序排序后交换, 注意, 这里交换的是首字
母, 而不是整个字符串, 所以程序输出: afg ebcd hnopq mijkl, 本题答案 B
[31] 有下列程序
- #include <stdio.h>
- void main()
- {
- char v[5][10] = { "efg","abcd","snopq","hijkl","xyz" };
- printf("%s,%c,%s,%c,%s" , *v, **(v + 3), v[4] + 2, *(v[2] + 4),v[1] + 1);
- }
程序执行后的输出结果是() .
A.efg, h, z, q, bcd
B.efg, d, zyz, w, bbcd
C.efgabcdsnopqhijklxyz, h, z, q, bcd
D.efgabcdsnopqhijklxyz, d, zyz, w, bbcd
参考答案: A
程序定义一个二维字符数组 v, 使用 5 个字符串初始化, 对于表达式: v 等价于 (v + 0), 输出的是数组 v 的第一个元素: efg;**(v + 3) 等价于 ((v + 3) + 0), 输出的是数组 v 的第四个元素的第一个字符: h;v[4] 表示数组 v 的第五个元素, v[4] + 2 表示输出从下标 2 开始的所有字符: z;v[2]表示数组 v 的第三个元素,*(v[2] + 4)表
示数组 v 的第三个元素的下标为 4 的字符: q,v[1] + 1 表示数组 v 的第二个元素从下标 1 开始的子字符串, 即: bcd, 本题输出: efg, h, z, q, bcd, 本题答案 A
[32] 有下列程序
- #include <stdio.h>
- #include <string.h>
- void main()
- {
- char a[5][10] = { "efg","abcd","mnopq","hijkl","rstuvwxyz" };
- char *p[5];
- int i, len;
- for (i = 0; i <5; i++)
- {
- p[i] = a[i];
- len = strlen(p[i]);
- printf("%c", p[i][0]);
- printf("%s", p[i] + len / 2);
- }
- }
程序执行后的输出结果是() .
- A.eeaabmmnhhirrstu
- B.efgabcdmnopqhijklrstuvwxyz
- C.efgacdmopqhjklrvwxyz
- D.eefgaabcdmmnopqhhijklrrstuvwxyz
参考答案: C
程序定义一个二维字符数组 a, 使用 5 个字符串初始化, 另外定义字符指针数组 p,for 循环中, 每次将数组 a 当前下标为 i 的字符串首地址赋给 p[i], 再求得 p[i]的长度赋给 len, 第一个 printf 输出 p[i]字符串的首字母, 第二个 printf 输出 p[i]字符串下标从 len / 2 开始的子字符串, 所以:
下标 i = 0 输出: efg
下标 i = 1 输出: acd
下标 i = 2 输出: mopq
下标 i = 3 输出: hjkl
下标 i = 4 输出: rvwxyz
程序输出: efgacdmopqhjklrvwxyz, 本题答案 C
[33] 有下列程序
- #include <stdio.h>
- int f(int x)
- {
- if (x <2)
- return 1;
- return x*f(x - 1) + (x - 1) *f(x - 2);
- }
- void main()
- {
- int y;
- y = f(4);
- printf("%d\n", y);
- }
程序执行后的输出结果是() .
- A.11
- B.43
- C.57
- D.53
参考答案: D
函数 f 是一个递归函数, 当 x>= 2 时, 递归调用自身, 返回值为: xf(x - 1) + (x - 1)f(x - 2), 当 x <2 时, 返回值为 1.main 函数中, 调用函数 f 传入 4, 所以 y 的值是 f(4).
f(4)等价于 4*f(3) + 3*f(2)
f(3)等价于 3*f(2) + 2*f(1)
f(2)等价于 2*f(1) + 1*f(0)
f(0),f(1)等价于 1
综上: f(2)等于 3,f(3)等于 11,f(4)等于 53, 本题答案 D
[34] 有下列程序
- #include <stdio.h>
- int a = 5;
- int func(int d)
- {
- int b = 5;
- static int c = 5;
- a--; b--; --c; --d;
- return a + b + c + d;
- }
- void main()
- {
- int k, a = 4;
- for (k = 0; k <3; k++)
- printf("%d,", func(a--));
- }
程序执行后的输出结果是() .
- A.15, 12, 9,
- B.15, 13, 11,
- C.15, 11, 7,
- D.15, 15, 15,
参考答案: A
程序定义整型的全局变量 a, 初值为 5,main 函数定义整型局部变量 a, 初值也是 5, 所以在 main 函数中, 局部变量 a 屏蔽全局变量 a;func 函数中定义局部变量 b, 初值为 5, 定义静态变量 c, 初值为 5, 并且在 func 函数中变量 a 引用的是全局变量 a. 综上, 我们使用 a_a 代表全局变量 a, 使用 m_a 代表 main 函数中局部变
量 a.
main 函数中, k = 0 时, a_a = 5, m_a = 4, 调用函数 func(4), 函数 func 中 d 的值为 4,b 的值为 5,c 的值为 5, 执行表达式 a_a--; b--; --c; --d; 后, a_a 的值为 4,b 的值为 4,c
的值为 4,d 的值为 3,a + b + c + d 的值为 15, 程序输出 15
k = 1 时, a_a = 4, m_a = 3, 调用函数 func(3), 函数 func 中 d 的值为 3,b 的值为 5,c 的值为 4(静态变量使用上一次调用结束时的值), 执行表达式 a_a--; b--; --c; --d; 后,
a_a 的值为 3,b 的值为 4,c 的值为 3,d 的值为 2,a + b + c + d 的值为 12, 程序输出 12
k = 2 时, a_a = 3, m_a = 2, 调用函数 func(2), 函数 func 中 d 的值为 2,b 的值为 5,c 的值为 3, 执行表达式 a_a--; b--; --c; --d 后, a_a 的值为 2,b 的值为 4,c 的值为 2,d 的值
为 1,a + b + c + d 的值为 9, 程序输出 9. 综上, 本题答案: A
[35] 有下列程序
- #include <stdio.h>
- #define S1(x, y) x*y
- #define S2(x, y) (x) *(y)
- void main()
- {
- int a = 2, b = 5;
- printf("%d,%d,%d,%d", S1(a + b, a + b), S1(a + b, b + a), S2(a + b, a + b), S2(a + b, b + a));
- }
程序执行后的输出结果是() .
A.17, 17, 49, 49
B.17, 29, 49, 49
C.29, 29, 49, 49
D.49, 49, 49, 49
参考答案: B
对于题意中的宏, 替换如下: S1(a + b, a + b)等价于: a + b*a + b, 即 2 + 5*2 + 5, 等于 17
S1(a + b, b + a)等价于: a + b*b + a, 即 2 + 5*5 + 2, 等于 29
S2(a + b, a + b)等价于:(a + b)*(a + b), 即(2 + 5)*(2 + 5), 等于 49
S2(a + b, b + a)等价于:(a + b)*(b + a), 即(2 + 5)*(5 + 2), 等于 49
本题答案: B
[36] 有下列程序
- #include <stdio.h>
- #include <string.h>
- typedef struct stu {
- char name[9];
- char gender;
- int score;
- } STU;
- STU a = { "Zhao", 'm', 85 };
- STU f()
- {
- STU c = { "Sun", 'f', 90 };
- strcpy(a.name, c.name);
- a.gender = c.gender;
- a.score = c.score;
- return a;
- }
- void main()
- {
- STU b = { "Qian", 'f', 95 };
- b = f();
- printf("%s,%c,%d,%s,%c,%d", a.name, a.gender, a.score, b.name, b.gender, b.score);
- }
程序执行后的输出结果是() .
A.Sun, f, 90, Sun, f, 90
B.Zhao, m, 85, Sun, f, 90
C.Zhao, m, 85, Qian, f, 95
D.Sun, f, 90, Qian, f, 95
参考答案: A
程序定义结构体类型 stu, 定义全局 stu 变量 a,main 函数定义局部 stu 变量 b, 并对它们初始化, 调用函数 f, 将局部变量 c 的各个成员值赋给 a, 覆盖 a 的旧值, 并将 a 的新值返回赋给 b, 此时 a,b 的各个成员值都是:"Sun", 'f', 90, 程序输出: Sun, f, 90, Sun, f, 90, 本题答案 A
[37] 有下列程序
- #include <stdio.h>
- typedef struct stu {
- char name[9];
- char gender;
- int score;
- } STU;
- void f(STU *a)
- {
- STU c = { "Sun", 'f', 90 }, *d = &c;
- *a = *d;
- printf("%s,%c,%d,", a->name, a->gender, a->score);
- }
- void main()
- {
- STU b = { "Zhao", 'm', 85 }, *a = &b;
- f(a);
- printf("%s,%c,%d", a->name, a->gender, a->score);
- }
程序执行后的输出结果是() .
A.Zhao, m, 85, Zhao, m, 85
B.Sun, f, 90, Zhao, m, 85
C.Zhao, m, 85, Sun, f, 90
D.Sun, f, 90, Sun, f, 90
参考答案: D
程序定义结构体类型 stu,main 函数定义结构体 stu 变量 b, 并将 b 的地址赋给指针变量 a, 调用函数 f, 传入 a, 在函数 f 中, 定义了 stu 变量 c, 并将 c 的地址赋给 d, 再用 d 指向的值赋给 a 指向的地址, 接着输出 a 指向的值, 也就是 c 的值: Sun, f, 90; 由于函数 f 的调用通过指针参数 a 修改了变量 b 的值, 所以 a 指向的值也就是 b 的
值等价于 c:Sun, f, 90. 本题答案 D
[38] 若有定义
- typedef int *T[10];
- T *a;
则以下与上述定义中 a 类型完全相同的是().
- A.int *a[10];
- B.int **a[10];
- C.int *(*a)[10];
- D.int *a[][10];
参考答案: B
由题意可知, T 是一个数组指针, 即 int [], 所以使用 T a 定义, 可知 a 属于 int **[]类型, 本题答案 B.
[39] 有下列程序
- #include <stdio.h>
- void main()
- {
- int x = 4, y = 2, z1, z2;
- z1 = x && y; z2 = x&y;
- printf("%d,%d\n", z1, z2);
- }
程序执行后的输出结果是() .
- A.1, 0
- B.1, 1
- C.1, 4
- D.4, 4
参考答案: A
&& 是逻辑与运算符, x,y 的取值为 4, 2, 两个都是非 0 值, 所以 x && y 的结果为真, 值为 1;& 是位运算符, x 的二进制为 0100,y 的二进制为 0010,0100&0010 的结果为 0, 本题答案 A
[40] 有下列程序
- #include <stdio.h>
- void main()
- {
- FILE *fp;
- int i, a[6] = { 1, 2, 3, 4, 5, 6 };
- fp = fopen("d.dat", "w+b");
- for (i = 5; i>= 0; i--)
- fwrite(&a[i], sizeof(int), 1, fp);
- rewind(fp);
- fread(&a[3], sizeof(int), 3, fp);
- fclose(fp);
- for (i = 0; i <6; i++)
- printf("%d,", a[i]);
- }
程序执行后的输出结果是() .
A.6, 5, 4, 4, 5, 6,
B.1, 2, 3, 4, 5, 6,
C.4, 5, 6, 4, 5, 6,
D.1, 2, 3, 6, 5, 4,
参考答案: D
程序定义数组 a, 使用 6 个元素对其初始化, 接着以写二进制方式打开文件 d.dat, 调用 fwrite 函数将 a 的 6 个元素逆序写入文件(654321), 接着调用 rewind 函数, 将文件指针移动到文件开始位置, 调用 fread 函数读入 3 个整数, 逐个存放到 a 开始下标为 3 的三个位置, 即 a[3] = 6, a[4] = 5, a[5] = 4, 关闭文件, 再次调用 for 循环
输出 a, 输出结果为: 1, 2, 3, 6, 5, 4.
本题答案: D
编程题
[41] 给定程序中, N 名学生的数据已存入类型为 STU 的结构体数组, 函数 fun 的作用是: 计算出 N 名学生的平均成绩, 将高于平均分的学生的学号存入 p 所指的存储单元中, 高于平均分的人数由函数值返回. 请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果. 注意: 源程序存放在文件 BLANK1.C 中, 不得增行或删行, 也不得更改程序的结构!
[参考答案]
(1)x[i].s (2)> ave (3)n++
(1)根据题意, STU 结构体中, num 数组存放学生学号, 变量 s 存放学生成绩. fun()函数需要计算 N 个学生的平均成绩 ave. 第一个 for 循环将 x 中 N 名学生的成绩累 加到 ave, 即 ave += x[i].s, 循环结束后再除以 N. (2)fun()函数求得 N 名学生的平均值后, 再次遍历数组 x, 将成绩高于平均值 ave 的学生学号存放到指针 p 指向的存储单元中, 所以 if 语句中需要判断 x[i].s> ave. (3)n 的初值为 0, 每次将成绩高于平均值 ave 的学生学号使用 strcpy 拷贝到 p 指向的第 n 个存储单元后, 需要对 n 自增 1, 表示下一个可用的存储单元索引, 也表示当 前存放到 p 中的学生学号的个数, 最后会作为函数返回值返回.
[42] 给定程序 MODI1.C 中, 函数 fun 的功能是: 将 a 串奇数位置 (注意: 不是下标) 上的字符与 b 串偶数位置上的字符交叉合并, 形成一个新字符串存入 c 所指的存储空间. 合并过程中, 任何一个字符串到达串尾, 则合并过程结束. 例如, a 串为: asderty b 串为: zxcvb 则 c 串为: axdvr 请改正程序中的错误, 使它能得出正确的结果. 注意: 不要改动 main 函数, 不得增行或删行, 也不得更改程序的结构!
[参考答案]
(1)if (b[i + 1] != '\0') (2)break; (3)c[j] = '\0';
(1)根据题意, fun()函数的每一轮 whie 循环, 需要将 a[i]存放到 c[j],b[i + 1]存放到 c[j + 1], 直到 a[i]或 b[i + 1]为空字符为止. 循环最后需要对 i 自增 2, 保证 a[i]是 a 的奇 数位置字符, b[i + 1]是 b 的偶数位置字符, 所以第一处需要修改为: if (b[i + 1] != '\0') (2)由 (1) 可知, else 表示 b[i + 1] == '\0', 此时按照题意, 程序应该跳出 while 循环, 所以 continue 应该修改为 break. (3)while 循环中每次将字符存放到 c[j]后, 都对 j 自增 1, 所以 j 始终指向 c 最后一个有效字符的下一个位置. 循环结束后只需要对 c[j]存放空字符即可, 所以 c[j + 1] = '\0'修改为 c[j] = '\0'.
[43] 程序中定义了 N*N 的二维数组, 并已在主函数中赋初值. 请编写函数 fun, 其功能是: 将 a 所指数组主对角线上的元素分别乘以 2; 次对角线上的元素分别乘以 3, 依次放入指针 p 所指的数组中. 计算过程中不得修改 a 所指数组中的 数据. 注意: 部分源程序在文件 PROG1.C 中. 请勿改动主函数 main 和其他函数中的任何内容, 仅在函数 fun 的花括号中填入所编写的若干语句.
[参考答案]
void fun(int a[N][N], int \*p) { int i, k = 0; for (i = 0; i < N; i++){ p[k++] = a[i][i] \* 2; } for (i = 0; i < N; i++){ p[k++] = a[i][N - i - 1] \* 3; } }
首先需要理解, 题意中二维数组的主对角线元素是指行下标和列下标相等的元素, 次对角线元素是指行下标和列下标之和为 N - 1 的元素. 接下来编写 fun 函数, 程序定义两个变量 i 和 k,k 初值为 0, 通过两个 for 循环完成题意要求, 第一个 for 循环遍历二维数组的主对角线元素 a[i][i], 乘 2 后赋值给 p[k], 再
对 k 自增 1; 第二个 for 循环遍历二维数组的次对角线元素 a[i][N - i - 1], 乘 3 后赋值给 p[k], 再对 k 自增 1.
来源: http://www.bubuko.com/infodetail-3448545.html