- C语言源程序的基本单位是(B).
(A).过程
(B).函数
©.子程序
(D).标识符 - 下列程序的输出结果是(B).
main()
{char c1=97,c2=98;
printf(“%d %c”,c1,c2);
}
(A).97 98
(B).97 b
©.a 98
(D).a b - 下列四个选项中,均是C语言关键字的选项是(B).
(A).auto enum include
(B).switch typedef continue
©.signed union scanf
(D).if struct type
选项(A)中，"auto"和"include"不是C语言的关键字。"auto"是其他一些语言（如C++）中的关键字，用于声明自动存储期变量；"include"是一个预处理指令，用于包含头文件。
选项(B)中，"switch"、"typedef"和"continue"都是C语言的关键字。"switch"用于多路选择，"typedef"用于定义类型别名，"continue"用于跳过循环的剩余部分。
选项(C)中，"signed"和"scanf"不是C语言的关键字。"signed"是其他一些语言（如C++）中的关键字，用于声明有符号整数；"scanf"是一个标准库函数，用于从标准输入读取格式化的数据。
选项(D)中，"if"和"struct"是C语言的关键字，但"type"不是。"if"用于条件语句，"struct"用于定义结构体，"type"不是C语言的关键字。
因此，选项(B)是唯一一个包含三个都是C语言关键字的选项。所以正确答案是(B)。
- 以下能对二维数组a进行正确初始化的语句是(B).
(A).int a[2][]={{1,0,1},{5,2,3}};
(B).int a[][3]={{1,2,3},{4,5,6}};
©.int a[2][4]={{1,2,3},{4,5},{6}};
(D).int a[][3]={{1,0,1}{},{1,1}};
在 C 语言中，二维数组的初始化需要指定数组的行数和列数。选项 (B) 中的语句使用了空的方括号 [] 表示数组的行数不确定，但列数为 3。然后，通过大括号 {} 进行初始化，第一个大括号内的值 {1, 2, 3} 初始化了第一行，第二个大括号内的值 {4, 5, 6} 初始化了第二行。
选项 (A) 中的语句出现了只省略列数的情况，这是不允许的。
选项 (C) 中的语句在第二行的大括号内的值的数量和每行的列数不一致，导致语法错误。这确实是部分初始化的情况，但数组的每行的列数应该相等。
选项 (D) 中的语句在第一个大括号内的第二个元素后缺少逗号，导致语法错误。
因此，选项 (B) 是能够对二维数组 a 进行正确初始化的语句。
- 以下对枚举类型名的定义中正确的是(B).
(A).enum a={sun,mon,tue};
(B).enum a {sun=9,mon=-1,tue};
©.enum a={“sun”,“mon”,“tue”};
(D).enum a {“sun”,“mon”,“tue”};
选项 (A) 中使用了赋值语句初始化枚举类型变量，这是不允许的。枚举类型变量只能被赋值为预定义的枚举常量。
选项 (C) 中试图将字符串常量赋值给枚举类型变量，这是不允许的。枚举类型变量只能被赋值为预定义的枚举常量。
选项 (D) 中省略了枚举常量的取值，这是不合法的。
因此，只有选项 (B) 中的枚举类型定义是正确的。其中，枚举类型名为 a，包含三个枚举常量 sun、mon 和 tue，它们的取值分别为 9、-1 和默认值（即比前一个枚举常量大 1）。
- 以下选项中合法的用户标识符是(B).
(A).long
(B)._2Test
©.3Dmax
(D).A.dat
(A) `long` 是C语言的保留关键字，所以它不能作为用户标识符。
(B) `_2Test` 符合规则，因为它以下划线开头，然后是字母和数字。
(C) `3Dmax` 违反了规则，因为它以数字开头。
(D) `A.dat` 违反了规则，因为它包含了一个点（.）。
- 以下叙述中正确的是(B).
(A).C语言的源程序不必通过编译就可以直接运行
(B).C语言中的每条可执行语句最终都将被转换成二进制的机器指令
©.C源程序经编译形成的二进制代码可以直接运行
(D).C语言中的函数不可以单独进行编译
(A) C语言源程序必须先经过编译成二进制代码，然后才能运行。
(B) C语言中的每条可执行语句最终都将被转换成二进制的机器指令。这是正确的。C语言的编译器将源代码转换成机器码，也就是二进制代码，这样计算机才能理解并执行。
(C)编译后的二进制代码通常需要链接器将其与库文件和其他必要的二进制文件链接起来，才能形成一个可执行文件，然后才能运行。
(D)在C语言中，函数可以单独编译成目标文件（.o文件），然后再通过链接器链接成一个可执行文件。
综上所述，正确的选项是：(B)。
- 以下叙述中不正确的是(B).
(A).一个好的程序应该有详尽的注释
(B).在C程序中,赋值运算符的优先级最低
©.在C程序中,j++;是一条赋值语句
(D).C程序中的#include和#define均不是C语句
不正确的叙述是 (B)。在C程序中，赋值运算符的优先级并不是最低的。
在 C 语言中，赋值运算符的优先级是从右向左的，但它并不是最低的优先级。实际上，C 语言中还有一些运算符的优先级比赋值运算符更低，例如逗号运算符和条件运算符（三目运算符）等。
选项 (A) 中叙述了一个好的程序应该有详尽的注释，这是一个良好的编程实践，可以提高代码的可读性和维护性。
选项 (C) 中叙述了 j++; 是一条赋值语句。实际上，j++; 是一个自增操作，它会将变量 j 的值加一，并将结果赋值回 j。
选项 (D) 中叙述了 #include 和 #define 不是 C 语句。这是正确的，#include 和 #define 是 C 预处理器指令，用于包含头文件和定义宏，并不属于 C 语句的范畴。
因此，选项 (B) 中的叙述是不正确的。
46. 若有以下程序段:int a=3,b=4; a=ab;b=ba;a=a^b;则执行以上语句后,a和b的值分别是(B).
(A).a=3,b=4
(B).a=4,b=3
©.a=4,b=4
(D).a=3,b=3
执行以上语句后，a 和 b 的值分别是 (B)。即 a=4，b=3。
这段程序使用了异或运算符（^）进行变量交换。异或运算具有以下特性：
对于任意整数 a，a^a 的结果为 0。
对于任意整数 a，a^0 的结果仍为 a。
按照程序的执行顺序进行推导：
a = a^b，此时 a = 3^4 = 7。
b = b^a，此时 b = 4^7 = 3。
a = a^b，此时 a = 7^3 = 4。
因此，执行完以上语句后，a 的值变为 4，b 的值变为 3。所以选项 (B) 正确
47.假定所有变量均已正确定义,下列程序段运行后x的值是(B).
k1=1;
k2=2;
k3=3;
x=15;
if(!k1) x–;
else if(k2) x=4;
else x=3;
(A).14
(B).4
©.15
(D).3
按照程序的执行顺序进行推导：
k1 = 1;
k2 = 2;
k3 = 3;
x = 15;
if (!k1) x--; 因为 k1 的值为 1，所以条件表达式 !k1 为假，不执行 x-- 操作。
else if (k2) x = 4; 因为 k2 的值为 2，所以条件表达式 k2 为真，执行 x = 4。
else x = 3; 因为前一个条件已经满足，所以不会执行这一步。
因此，最终的结果是 x = 4。所以选项 (B) 是正确的。
-
给数组a的所有元素分别赋值为1、2、3、……的语句是(B).
(A).for(i=1;i<11;i++)a[i]=i;
(B).for(i=1;i<11;i++)a[i-1]=i;
©.for(i=1;i<11;i++)a[i+1]=i;
(D).for(i=1;i<11;i++)a[0]=1; -
C语言中不可以嵌套的是(B).
(A).函数调用
(B).函数定义
©.循环语句
(D).选择语句 -
int a[10]={1,2,3,4,5,6,7,8};int *p;p=&a[5];p[-3]的值是(B)
(A).2
(B).3
©.4
(D).不一定
首先，我们将变量 a 初始化为一个包含 10 个元素的整数数组，并赋予初始值。其中，a[0] = 1，a[1] = 2，a[2] = 3，a[3] = 4，a[4] = 5，a[5] = 6，a[6] = 7，a[7] = 8，其余元素默认初始化为 0。
然后，我们声明一个指针变量 p，并将其指向数组中的第 6 个元素，即 a[5]。此时，p 的值等于 &a[5]。
接下来，我们使用 p[-3] 访问 p 指针所指向的位置前面 3 个元素的值。在这里，p[-3] 实际上是对数组中的第 2 个元素 a[2] 进行访问。因此，p[-3] 的值是 4。
所以，选项 (C) 4 是正确的答案。
- 若k为int型变量,则以下程序段的执行结果是(B).
k=-8567; printf(“|%06D|\n”,k);
(A).格式描述符不合法,输出无定值
(B).输出为|%06D|
©.输出为|0-8567|
(D).输出为|-8567|
在这段代码中，格式描述符"%06D"指定了一个六位数的宽度，并且使用大写字母D来表示待输出的整数。然而，大写字母D并不是有效的格式描述符，因此它将按照普通字符进行输出。所以输出结果为"|%06D|"，其中%06D被原样输出。
52. fseek函数的正确调用形式是(B).
(A).fseek(文件类型指针,起始点,位移量)
(B).fseek(fp,位移量,起始点)
©.fseek(位移量,起始点,fp)
(D).fseek(起始点,位移量,文件类型指针)
- 下列表达式中,可作为C合法表达式的是(B).
(A).[3,2,1,0]
(B).(3,2,1,0)
©.3=2=1=0
(D).3/2/1/0
选项 (A) [3,2,1,0] 不是合法的 C 表达式。在 C 语言中，方括号用于表示数组，而不是用于表示元组或序列。
选项 (C) 3=2=1=0 是不合法的表达式。在 C 语言中，等号 (=) 是赋值运算符，不能连续使用进行多重赋值。
选项 (D) 3/2/1/0 是合法的表达式，但根据算术运算规则，除数不能为0。因此，在这个表达式中，当除法运算中出现 0 作为除数时，会导致错误或异常。
只有选项 (B) (3,2,1,0) 是合法的 C 表达式，它表示一个包含四个整数的元组。
- 以下程序的输出结果为(B).
main()
{int a=1,b=2,c=3,d=4,e=5;
printf(“%d\n”,func((a+b,b+c,c+a),(d+e)));
}
int func(int x,int y)
{
return(x+y);
}
(A).15
(B).13
©.9
(D).函数调用出错
首先，我们来分析 printf 函数中的参数：func((a+b,b+c,c+a),(d+e))。
这个参数包含两个部分：(a+b,b+c,c+a) 和 (d+e)。
对于 (a+b,b+c,c+a)，逗号运算符会先计算 a+b，然后计算 b+c，最后计算 c+a。所以 (a+b,b+c,c+a) 的结果是 c+a，即 3+1=4。
对于 (d+e)，计算结果是 4+5=9。
因此，最终的 printf 输出结果为 13。
选项 (B) 13 是正确的答案。
- 以下标识符中,不能作为合法的C用户定义标识符的是(B).
(A).a3_b3
(B).void
©._123
(D).IF
C 语言中，标识符是用户定义的用于标识变量、函数、结构体等各种数据类型的名称。标识符必须满足以下规则：
标识符由字母、数字和下划线组成。
第一个字符必须是字母或下划线。
标识符长度不能超过 31 个字符。
标识符对大小写敏感。
选项 (A) a3_b3、(C) _123、(D) IF 都满足上述规则，因此都可以作为合法的 C 用户定义标识符。
而关键字 void 是 C 语言中的一种保留字，表示无类型。保留字具有特殊的含义，不能用作普通的标识符，因此不能作为合法的 C 用户定义标识符。
因此，选项 (B) void 是不能作为合法的 C 用户定义标识符的。
- 假设所有变量均为整型,表达式:a=2,b=5,a>b?a++:b++,a+b的值是(B).
(A).7
(B).8
©.9
(D).2
57. 以下程序段的输出结果为(B).
for(i=4;i>1;i–)
for(j=1;j<i;j++)
putchar(‘#’);
(A).无
(B).######
©.#
(D).###
外层循环控制变量 i 从 4 开始递减，每次循环内部执行内层循环。内层循环控制变量 j 从 1 开始递增，直到小于 i 时停止，并输出字符 #。
首先，当 i 等于 4 时，内层循环执行三次，输出三个 #。
然后，当 i 等于 3 时，内层循环执行两次，输出两个 #。
最后，当 i 等于 2 时，内层循环执行一次，输出一个 #。
- 设C语言中,int类型数据占2个字节,则unsigned类型数据占(B).
(A).1个字节
(B).2个字节
©.4个字节
(D).8个字节
int（整型）：
16位平台：2字节
32位平台：4字节
64位平台：4字节
short（短整型）：
16位平台：2字节
32位平台：2字节
64位平台：2字节
long（长整型）：
16位平台：4字节
32位平台：4字节
64位平台：8字节
char（字符型）：
16位平台：1字节
32位平台：1字节
64位平台：1字节
double（双精度浮点型）：
16位平台：8字节
32位平台：8字节
64位平台：8字节
float（单精度浮点型）：
16位平台：4字节
32位平台：4字节
64位平台：4字节
需要注意的是，上述字节数只是一般情况下的表现，具体的字节数可能会因编译器、操作系统和编译选项等因素而有所变化。可以使用 sizeof 运算符来获取特定数据类型在当前平台上的字节数。例如，sizeof(int) 可以用于获取 int 类型的字节数。
- 对 for(表达式1; ;表达式3) 可理解为(B).
(A).for(表达式1;0;表达式3)
(B).for(表达式1;1;表达式3)
©.for(表达式1;表达式1;表达式3)
(D).for(表达式1;表达式3;表达式3)
60. C语言中,定义结构体的保留字是(B).
(A).union
(B).struct
©.enum
(D).typedef
选项 (A) union 是另一种自定义的数据类型，与结构体类似，也可以将多个不同类型的数据组合在一起形成一个新的数据类型，其定义方式为使用 union 关键字。但不同的是，union 中所有成员共用同一块内存空间，因此 union 只能存储其中的一个成员值。
选项 (C) enum 是枚举类型的关键字，枚举类型也是一种自定义的数据类型，用于定义一组命名的常量，常用于表示状态、选项等离散值。
选项 (D) typedef 是类型定义的关键字，可以通过 typedef 将已有的类型定义为新的类型名称，方便程序中的使用。
因此，C 语言中定义结构体的保留字是 (B) struct。
- 设C语言中,int类型数据占2个字节,则short类型数据占().B
(A).1个字节
(B).2个字节
©.4个字节
(D).8个字节 - 对 for(表达式1; ;表达式3) 可理解为(B).
(A).for(表达式1;0;表达式3)
(B).for(表达式1;1;表达式3)
©.for(表达式1;表达式1;表达式3)
(D).for(表达式表达式3;表达式3) - C语言允许函数类型缺省定义,此时函数值隐含的类型是().B
(A).float
(B).int
©.long
(D).double
64. 若有int a[][2]={{1,2},{3,4}}; 则*(a+1),*(*a+1)的含义分别为(B).
(A).非法,2
(B).&a[1][0],2
©.&a[0][1],3
(D).a[0][0],4
对于 int a[][2]={{1,2},{3,4}};，数组 a 是一个包含两行两列的二维整型数组。其中，第一行包含元素 {1, 2}，第二行包含元素 {3, 4}。
*(a+1) 表示指针 a 加上 1，即指向数组中的第二行。因此，*(a+1) 的值是指向数组中第二行的指针，即 &a[1][0]。
*(*a+1) 表示指针 a 解引用后再加上 1，即指向数组中第一个元素的后面一个位置。因为 *a 等价于 a[0]，所以 *(*a + 1) 实际上是 a[0][1] 的值，即 2。
因此，选项 (B) &a[1][0] 和 2 是正确的答案。
- 以下叙述正确的是(B).
(A).可以把define和if定义为用户标识符
(B).可以把define定义为用户标识符,但不能把if定义为用户标识符
©.可以把if定义为用户标识符,但不能把define定义为用户标识符
(D).define和if都不能定义为用户标识符
在C语言中，define 是一个预处理器指令，用于定义宏。宏名可以被定义为用户标识符。
然而，if 不可以被定义为用户标识符，因为它是C语言中的关键字，具有特定的语法和功能，不能用作标识符。
66. sizeof(float)是(B).
(A).一个双精度型表达式
(B).一个整型表达式
©.一种函数调用
(D).一个不合法的表达式
sizeof 是 C 语言中的一个关键字，用于计算数据类型或变量所占内存的大小，返回值的类型是 size_t，是一个无符号整数类型。因此，sizeof(float) 表示 float 类型的变量所占内存的大小，其返回值是一个整数，因此 sizeof(float) 是一个整型表达式。
-
对 for(表达式1; ;表达式3) 可理解为(B).
(A).for(表达式1;0;表达式3)
(B).for(表达式1;1;表达式3)
©.for(表达式1;表达式1;表达式3)
(D).for(表达式1;表达式3;表达式3) -
若有说明:int i, j=2,*p=&i;,则能完成i=j赋值功能的语句是(B).
(A).i=*p;
(B).p=&j;
©.i=&j;
(D).i=**p; -
下面四个选项中,均是不合法的浮点数的选项是(B).
(A).160. 0.12 e3
(B).123 2e4.2 .e5
©.-.18 123e4 0.0
(D).-e3 .234 1e3 -
在一个C程序中(B).
(A).main函数必须出现在所有函数之前
(B).main函数可以在任何地方出现
©.main函数必须出现在所有函数之后
(D).main函数必须出现在固定位置
71. 若二维数组a有m列,则在a[i][j]前的元素个数为(B).
(A).j * m+i
(B).i * m+j
©.i *m+j-1
(D).i * m+j+1
在二维数组中，假设有m列，则a[i][j]前的元素个数可以通过以下方式计算：
每一行有m个元素；
在第i行之前，有i行；（自行举例便一目了然）
在第i行中，第j列之前还有j个元素；
因此，a[i][j]前的元素个数为 i * m + j。选项(B)符合这个计算公式。
- 若有下列定义,则对a数组元素地址的正确引用是(B).
int a[5],*p=a;
(A).&a[5]
(B).p+2
©.a++
(D).&a
(A) `&a[5]`：尝试访问数组的第6个元素（因为数组索引从0开始）。但实际上，数组只有5个元素，所以这是越界的。
(B) `p+2`：这实际上是取数组第3个元素的地址。因为`p`指向数组的第一个元素，所以`p+2`指向数组的第3个元素。
(C) `a++`：这实际上是增加数组名（即指针）的值，使其指向下一个元素。但这不是一个引用数组元素的地址，而是一个临时指针。
(D) `&a`：这实际上是取数组名（即指向数组第一个元素的指针）的地址，而不是数组元素的地址。
所以，只有选项(B) `p+2`是正确引用数组元素地址的方式。
- 下列字符序列中,不可用作C语言标识符的是(B).
(A).b70
(B).#ab
©.symbol
(D).a_1
74. 以下不正确的说法是:C语言规定(B).
(A).实参可以是常量,变量或表达式
(B).形参可以是常量,变量或表达式
©.实参可以为任何类型
(D).形参应与其对应的实参类型一致
C语言中形参不可以是表达式
- 下列数据中,为字符串常量的是(B).
(A).A
(B).“house”
©.How do you do.
(D).$abc
76. 在位运算中,操作数每右移一位,其结果相当于(B).
(A).操作数乘以2
(B).操作数除以2
©.操作数乘以16
(D).操作数除以16
- 以下所列的C语言常量中,错误的是(B).
(A).0xFF
(B).1.2e0.5
©.2L
(D).‘\72’
78. 为了提高程序的运行速度,在函数中对于整型或指针可以使用(B)型的变量.
(A).auto
(B).register
©.static
(D).extern
寄存器比内存访问要快，因此可以使用register关键字将C程序中最常用的变量放入寄存器中。
关键字register会向编译器提示可以将给定变量放入寄存器中。 编译器可以选择是否将其保存在寄存器中。
-
int a=1,b=2,c=3;
if(a>c)b=a;a=c;c=b;则c的值为().B
(A).1
(B).2
©.3
(D).不一定 -
以下不正确的定义语句是(B).
(A).double x[5]={2.0,4.0,6.0,8.0,10.0};
(B).int y[5]={0,1,3,5,7,9};
©.char c1[]={‘1’,‘2’,‘3’,‘4’,‘5’};
(D).char c2[]={‘\x10’,‘\xa’,‘\x8’};
不正确的定义语句是 (B) int y[5]={0,1,3,5,7,9}。
在 C 语言中，数组的定义需要指定数组的长度，以便为其分配足够的内存空间。
选项 (B) 中的定义语句 int y[5]={0,1,3,5,7,9} 指定了数组 y 的长度为 5，但是初始化列表中提供了 6 个元素。
这违反了数组长度与实际元素数量不匹配的规定，因此该定义语句是不正确的。
- C语言规定:简单变量做实参时,它和对应形参之间的数据传递方式是(B).
(A).地址传递
(B).单向值传递
©.由实参传给形参,再由形参传回给实参
(D).由用户指定的传递方式
C 语言规定，简单变量做实参时，它和对应形参之间的数据传递方式是 (B) 单向值传递。
在 C 语言中，数据传递的方式可以分为：值传递和引用传递。
值传递是指将实参的值复制一份，传递给形参。这意味着在函数内部对形参的修改不会影响到实参本身。
引用传递是指将实参的地址传递给形参，形参可以通过地址访问和修改实参的值。
对于简单变量作为实参，C 语言采用的是值传递方式，也就是单向值传递。
当简单变量作为实参传递给形参时，实参的值会被复制到形参中。
在函数内部对形参的修改不会影响到原始的实参。
因此，选项 (B) 单向值传递是正确的答案。
- 以下程序的输出结果是(B).
main()
{ char s[]=“123”,*p;
p=s;
printf(“%c%c%c\n”,*p++,*p++,*p++);
}
(A).123
(B).321
©.213
(D).312
这段程序的输出结果是 (B) 321。
原因是，先执行 *p++，将指针 p 指向的元素取出来，即字符 '1'，然后 p 指针加 1，指向下一个元素 '2'。接着再执行一次 *p++，将指针 p 指向的元素取出来，即字符 '2'，然后 p 指针再加 1，指向下一个元素 '3'。最后再执行一次 *p++，将指针 p 指向的元素取出来，即字符 '3'，然后 p 指针再加 1，此时 p 指针已经越界，指向了字符串末尾的空字符 \0。
因此，printf 函数会按照 %c%c%c 的格式依次输出字符 3、2 和 1，最终输出结果为 321。
- 以下语句中,不能实现回车换行的是(B).
(A).printf(“\n”);
(B).putchar(“\n”);
©.fprintf(stdout,“\n”);
(D).fwrite(“\n”,1,1,stdout);
选项 (B) 中的语句 putchar("\n") 不能实现回车换行。
原因是 putchar 函数的参数应该是一个字符，而不是一个字符串。在 C 语言中，用单引号表示字符，用双引号表示字符串。因此，正确的方式应该是使用单引号来表示换行字符 putchar('\n')。
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
