C语言期末复习【选择题D篇】
-
C语言中,double类型数据占(D).
(A).1个字节
(B).2个字节
©.4个字节
(D).8个字节 -
设a为整型变量,初值为12,执行完语句a+=a-=a*a后,a的值是(D).
(A).552
(B).144
©.264
(D).-264
根据运算符的优先级和结合性，我们可以逐步分析这个复合赋值表达式的执行过程：
首先计算 a * a，即 12 * 12，结果为 144。
接下来执行 a -= 144，相当于 a = a - 144，即 a = 12 - 144，结果为 -132。
最后执行 a += -132，相当于 a = a + (-132)，即 a = -132 + (-132)，结果为 -264。
因此，执行完语句a+=a-=a*a后，a 的值是 -264。选项 (D). -264 是正确的答案。
134. 下列程序的输出为(D).
main()
{ int y=10;
while(y–) ;
printf(“y=%d\n”,y);
}
(A).y=0
(B).while构成无限循环
©.y=1
(D).y=-1
程序中有一个 while 循环，每次循环时 y 的值会减1，直到 y 为0时，循环停止。然后在循环外使用 printf 打印 y 的值。
初始时 y 的值为 10，进入循环后，循环体为空，因此什么都不执行，只是简单地将 y 的值减1。循环会执行10次，直到 y 的值为0时，循环停止。
循环结束后，y 的值变为 -1。然后使用 printf 打印 y 的值，输出结果为 y=-1。
因此，程序的输出为 (D). y=-1。
-
以下能正确定义数组并正确赋初值的语句是(D).
(A).int N=5,b[N][N];
(B).int a[1][2]={{1},{3}};
©.int c[2][]={{1,2},{3,4}};
(D).int d[3][2]={{1,2},{3,4}}; -
若有说明: int a[][4]={0,0};则下面不正确的叙述是(D).
(A).数组a的每个元素都可得到初值0
(B).二维数组a的第一维大小为1
©.因为二维数组a中第二维大小的值除经初值个数的商为1,故数组a的行数为1
(D).有元素a[0][0]和a[0][1]可得到初值0,其余元素均得不到初值0
根据给定的声明 int a[][4]={0,0};，数组a是一个二维数组，第一维大小没有指定，第二维大小为4。由此，我们可以分析每个选项的正确性：
(A). 数组a的每个元素都可得到初值0 是正确的叙述。由于使用了初始化列表 {0, 0}，数组a的所有元素都将被初始化为0。
(B). 二维数组a的第一维大小为1 是正确的叙述。虽然声明中没有指定第一维的大小，但是初始化列表中只提供了一组初始值，因此第一维大小为1。
(C). 因为二维数组a中第二维大小的值除经初值个数的商为1，故数组a的行数为1 是正确的叙述。由于初始化列表中只提供了两个初始值，且第二维大小为4，所以 a 的行数为1。
(D). 根据初始化列表中的初始值，a[0][0] 和 a[0][1] 确实被初始化为0，而其他元素将被默认初始化为0。
因此，选项 (D). 有元素a[0][0]和a[0][1]可得到初值0，其余元素均得不到初值0 是不正确的叙述。
- C语言规定,函数返回值的类型是由(D).
(A).return语句中的表达式类型所决定
(B).调用该函数时的主调函数类型所决定
©.调用该函数时系统临时决定
(D).在定义该函数时所指定的函数类型所决定
138. 则下列语句中能够实现当字符串s1大于字符串s2时,输出s2的语句是(D).
(A).if(strcmp(s1,s1)>0)puts(s2);
(B).if(strcmp(s2,s1)>0)puts(s2);
©.if(strcmp(s2,t)>0)puts(s2);
(D).if(strcmp(s1,t)>0)puts(s2);
(A). if(strcmp(s1,s1)>0)puts(s2) 是无法实现所述要求的语句。这是因为 strcmp 函数中比较的是两个相同的字符串 s1，结果将始终为 0，不满足条件。
(B). if(strcmp(s2,s1)>0)puts(s2) 是无法实现所述要求的语句。这是因为 strcmp 函数中比较的是 s2 和 s1 两个字符串，如果 s2 大于 s1，则 strcmp 返回值大于 0，但是输出的是 s2，而不是 s1。
(C). if(strcmp(s2,t)>0)puts(s2) 是无法实现所述要求的语句。这是因为 strcmp 函数中比较的是 s2 和 t 两个字符串，并不涉及 s1 和 s2 的比较。
(D). if(strcmp(s1,t)>0)puts(s2) 是能够实现所述要求的语句。这是因为 strcmp 函数比较的是 s1 和 t 两个字符串，如果 s1 大于 t，则 strcmp 返回值大于 0，满足条件，输出 s2。
因此，选项 (D). if(strcmp(s1,t)>0)puts(s2) 能够实现当字符串s1大于字符串s2时，输出s2的语句。
139. 下列选项中正确的语句组是(D).
(A).char s[8]; s={“Beijing”};
(B).char *s; s={“Beijing”}
©.char s[8]; s=“Beijing”;
(D).char *s; s=“Beijing”;
140. 以下叙述中错误的是(D).
(A).二进制文件打开后可以先读文件的末尾,而顺序文件不可以
(B).在程序结束时,应当用fclose函数关闭已打开的文件
©.在利用fread函数从二进制文件中读数据时,可以用数组名给数组中所有元素读入数据
(D).不可以用FILE定义指向二进制文件的文件指针
A). 二进制文件打开后可以先读文件的末尾，而顺序文件不可以。这是正确的叙述。在二进制文件中，我们可以使用 fseek 函数将文件指针移到文件的末尾，然后再进行读取操作。而在顺序文件中，我们只能按顺序逐个读取文件内容。
(B). 在程序结束时，应当用 fclose 函数关闭已打开的文件。这是正确的叙述。打开文件后，为了释放文件资源并确保文件内容被保存，应当在程序结束前关闭已打开的文件。
(C). 在利用 fread 函数从二进制文件中读数据时，可以用数组名给数组中所有元素读入数据。fread 函数可以一次性读取指定数量的数据到数组中，可以使用数组名直接传递给 fread 函数来实现。
(D).FILE 是 C 语言标准库中定义的结构体类型，用于表示文件流。我们可以使用 FILE 类型的指针作为文件指针，包括指向二进制文件的文件指针。
-
以下数组定义中不正确的是(D).
(A).int a[2][3];
(B).int b[][3]={0,1,2,3};
©.int c[100][100]={0};
(D).int d[3][]={{1,2},{1,2,3},{1,2,3,4}}; -
函数的形式参数隐含的存储类型说明是(D).
(A).extern
(B).static
©.register
(D).auto -
在定义构造数据类型时,不能(D).
(A).说明变量
(B).说明存储类型
©.初始化
(D).末尾不写分号 -
具有相同类型的指针变量p与数组a,不能进行的操作是(D).
(A).p=a;
(B).*p=a[0];
©.p=&a[0];
(D).p=&a; -
下列运算符中,不属于关系运算符的是(D).
(A).<
(B).>
©.>=
(D).!
146. 以下错误的描述是:函数调用可以(D).
(A).出现在执行语句中
(B).出现在一个表达式中
©.做为一个函数的实参
(D).做为一个函数的形参
(D)函数调用不会作为一个函数的形参，而是作为实参传递给其他函数。形参是在函数定义时声明的变量，用于接收函数调用时传递的实参值。实参则是在函数调用时提供的具体数值或表达式。
-
若有说明:int n=2,*p=&n,*q=p;,则以下非法的赋值语句是(D).
(A).p=q;
(B).*p=*q;
©.n=*q;
(D).p=n; -
下列字符序列中,可用作C标识符的一组字符序列是(D).
(A).S.b,sum,average,_above
(B).class,day,lotus_1,2day
©.#md,&12x,month,student_n!
(D).D56,r_1_2,name,_st_1 -
double x;scanf(“%lf”,&x);不可以赋值给x变量的常量是(D).
(A).123
(B).100000
©.‘A’
(D).“abc”
在C语言中，scanf函数可以用于从用户输入中读取数据并赋值给变量。不过，在给变量赋值时，有一些限制。
对于给 double 类型的变量赋值来说，选项(D). "abc"是不合法的：
因为 "abc" 是一个字符串常量，无法直接赋值给 double 类型的变量。scanf 函数用于读取输入，并将其转换为指定的格式，例如 "%lf" 用于读取 double 类型的数据。所以，我们可以使用 scanf 函数来读取用户输入的 double 类型数据，但是不能将字符串常量直接赋值给 double 变量。
150. 若int类型数据占两个字节,则下列语句的输出为(D).
int k=-1; printf(“%d,%u\n”,k,k);
(A).-1,-1
(B).-1,32767
©.-1,32768
(D).-1,65535
根据给定的语句，变量 k 被赋值为 -1，即在二进制补码表示下为全 1 的二进制数。
在使用 %d 格式进行输出时，会将其作为带符号整数输出，因此输出结果为 -1。
在使用 %u 格式进行输出时，会将其作为无符号整数输出，并将其按照二进制原码的方式输出，因此输出结果为 65535。
因此，输出结果为 -1,65535，与选项 (D) 相符。
151. 若k,g均为int型变量,则下列语句的输出为(D).
k=017; g=111; printf(“%d\t”,++k); printf(“%x\n”,g++);
(A).15 6f
(B).16 70
©.15 71
(D).16 6f
k=017; 将八进制数 017 赋值给变量 k，其对应的十进制是 15。
g=111; 将十进制数 111 赋值给变量 g。
printf("%d\t",++k); 先将 k 的值自增 1，然后以十进制格式打印输出，即输出 16。
printf("%x\n",g++); 先以十六进制格式打印输出 g 的值，即输出 6f；然后将 g 的值自增 1，但此时 g 的值不再使用。
因此，输出结果为 16 6f，与选项 (D) 相符。
-
以下不能正确定义二维数组的选项是(D).
(A).int a[2][2]={{1},{2}};
(B).int a[][2]={1,2,3,4};
©.int a[2][2]={{1},2,3};
(D).int a[2][]={{1,2},{3,4}}; -
下列定义数组的语句中不正确的是(D).
(A).static int a[2][3]={1,2,3,4,5,6};
(B).static int a[2][3]={{1},{4,5}};
©.static int a[][3]={{1},{4}};
(D).static int a[][]={{1,2,3},{4,5,6}}; -
在定义构造数据类型时,不能(D).
(A).说明变量
(B).说明存储类型
©.初始化
(D).末尾不写分号 -
下面说明不正确的是(D).
(A).char a[10]=“china”;
(B).char a[10],*p=a;p=“china”
©.char *a;a=“china”;
(D).char a[10],*p;p=a=“china”
段代码存在问题。在C语言中，字符串常量是不能被赋值给字符数组的，因为字符串常量是只读的，而字符数组是可读写的。因此，如果要将一个字符串常量的值赋给字符数组，需要使用字符串复制函数（如strcpy）或字符数组的遍历方式来逐个赋值。
另外，在你提供的代码中，赋值语句p=a="china"将会导致a和p指向同一块内存地址，但是p是一个指向字符类型的指针，不应该被赋值为一个字符数组的地址。
156. 若a=1,b=2则 a|b的值是(D).
(A).0
(B).1
©.2
(D).3
题目中的 a|b 表示对变量 a 和 b 进行按位或运算。按位或运算符 | 的运算规则是：对于每一位，只要两个操作数中有一个为 1，结果就为 1；否则结果为 0。
根据题目给出的条件，a=1，b=2，将它们转换为二进制表示：a 的二进制表示为 0001，b 的二进制表示为 0010。
对应位进行按位或运算，得到结果 0011。将结果转换为十进制表示，即 3。
因此，选项 (D) 的值为 3，即 a|b 的值为 3。
- 下列运算符中是C语言关系运算符的是(D).
(A).~
(B).!
©.&
(D).!=
158. C语言中要求对变量作强制定义的主要理由是(D).
(A).便于移植
(B).便于写文件
©.便于编辑预处理程序的处理
(D).便于确定类型和分配空间
- 以下不符合C语言语法的赋值语句是(D).
(A).j++;
(B).j=j=5;
©.k=(2 * 4,k * 4);
(D).y=float(j);
在 C 语言中，类型转换可以使用强制类型转换运算符来完成。然而，在选项 (D) 中，float(j) 并不是一个有效的类型转换表达式。如果要将整型变量 j 转换为浮点型，应该使用强制类型转换运算符，例如 (float)j。
选项 (A) 是合法的赋值语句，表示将变量 j 的值自增 1。
选项 (B) 是合法的赋值语句，将整数值 5 赋给变量 j，然后将变量 j 的值再赋给变量 j 自身。
选项 (C) 是合法的赋值语句，将表达式 (2*4, k*4) 的值赋给变量 k。逗号运算符在 C 语言中会先计算左侧表达式的值，然后忽略它，再计算并返回右侧表达式的值。因此，(2*4, k*4) 表达式的值等于 k*4 的值，这个值会被赋给变量 k。
-
在C语言中,if语句后的一对原括号中,用以决定分支的流程的表达式(D).
(A).只能用逻辑表达式
(B).只能用关系表达式
©.只能用逻辑表达式或关系表达式
(D).可用任意表达式 -
在C语言中,一维数组的定义方式为:类型说明符数组名(D).
(A).[常量表达式]
(B).[整型表达式]
©.[整型常量]或[整型表达式]
(D).[整型常量] -
以下标识符中,不能作为合法的C用户定义标识符的是(D).
(A).For
(B).Printf
©.WORD
(D).sizeof
163. 在C语言中,char型数据在内存中的存储形式是(D).
(A).补码
(B).反码
©.原码
(D).ASCII码
在内存中，char 和 int 类型的数据都是以二进制形式存储的。
在C语言中，char型数据在内存中的存储形式是使用 ASCII 码。
ASCII（American Standard Code for Information Interchange）码是一种字符编码标准，它定义了 128 个字符的编码方式，包括大小写字母、数字、标点符号和控制字符等。在 ASCII 码中，每个字符被赋予一个唯一的整数值。
在内存中，char 型数据通常占用一个字节（8位），用来存储一个字符的 ASCII 码。例如，字符 'A' 的 ASCII 码是 65（二进制表示为 01000001），在内存中存储时，会将字符 'A' 的 ASCII 码以二进制形式存储在一个字节中。
所以，在 C 语言中，char 型数据在内存中的存储形式是 ASCII 码。
整数类型（比如 int, long 等）在内存中存储时，使用的是补码的形式。补码是一种表示有符号整数的方法，它使用二进制数的最高位作为符号位，正数的补码与原码相同，负数的补码是对其原码取反（取反指的是将每一位的 0 变为 1，将每一位的 1 变为 0），然后再加 1。
例如，假设有一个 8 位补码系统，要存储整数 -5。首先，我们找到 5 的二进制表示形式为 00000101。然后，将其取反得到 11111010。最后，将其加 1 得到 -5 的补码表示形式为 11111011。
使用补码表示法的好处是可以简化计算机的硬件逻辑，将加法和减法操作统一为加法操作，且不需要额外处理符号位。此外，补码还可以避免出现两个零的表示，即 +0 和 -0 是相同的。
总结起来，在内存中，整数类型通常以补码形式存储，这样可以方便地进行算术运算和处理有符号数。
- 以下对一维整型数组a的正确说明是(D).
(A).int a(10);
(B).int n=10,a[n];
©.int n; scanf(“%d”,&n); int a[n];
(D).#define SIZE 10 (换行) int a[SIZE];
(A). int a(10); 这是错误的语法。应该使用方括号 [] 来声明数组大小，而不是小括号 ()。
(B). int n=10, a[n]; 这也是错误的语法。在 C 语言中，数组的大小必须是常量表达式。这意味着数组的大小必须在编译时就确定，而不能使用变量来指定。
(C). int n; scanf("%d", &n); int a[n]; 这是可行的语法，称为变长数组（Variable Length Array, VLA）。在 C99 标准中引入了变长数组的概念，允许使用变量来定义数组的大小。但需要注意的是，这在某些编译器或编译器设置中可能不被支持。
(D). #define SIZE 10
int a[SIZE]; 这是正确的语法。使用预处理指令 #define 定义了一个常量 SIZE，并将其设置为 10。然后使用 SIZE 来声明数组 a 的大小。这是一种常见且可靠的方式来定义数组大小。
165. 关于指针概念说法不正确的是(D).
(A).一个指针变量只能指向同一类型变量
(B).一个变量的地址称为该变量的指针
©.只有同一类型变量的地址才能放到指向该类型变量的指针变量之中
(D).指针变量可以由整数赋,不能用浮点赋
正确答案是 (D). 指针变量可以由整数赋值，也可以由浮点数赋值。
指针是用来存储内存地址的变量。下面对选项进行逐一解释：
(A). 一个指针变量只能指向同一类型变量：这是正确的。指针变量的类型必须与其指向的变量类型相匹配，否则会导致类型不匹配的错误。
(B). 一个变量的地址称为该变量的指针
(C). 只有同一类型变量的地址才能放到指向该类型变量的指针变量之中：这是正确的。指针变量必须指向与其类型相匹配的变量类型。
(D). 指针变量可以由整数赋值，也可以由浮点数赋值。在 C 语言中，整数可以直接赋给指针变量，而浮点数可以通过类型转换（例如使用强制类型转换）赋给指针变量。但需要注意的是，将浮点数赋给指针变量可能会导致精度丢失或者未定义的行为，因此在实际使用中应该避免这种情况。
166. 以下运算符中,优先级最高的运算符是(D).
(A).=
(B).!=
©.*(乘号)
(D).()
在 C 语言中，括号 () 的优先级是最高的，因此答案是 (D)。
具体来说，C 语言中的运算符优先级按照一定的规则进行排列，不同的运算符有不同的优先级。当表达式中包含多个运算符时，会按照优先级从高到低进行求值。而括号 () 具有最高的优先级，因此在表达式中出现括号时，其中的内容会先被求值。
以下是 C 语言中几个常见运算符的优先级（由高到低）：
()（括号）
[]（下标）
->（结构体成员访问）
++、--（自增和自减）
+、-（正负号和加减法）
!、~（逻辑非和按位取反）
*、/、%（乘法、除法、取模）
+、-（加法和减法）
<<、>>（左移和右移）
<、<=、>、>=（关系运算符）
==、!=（相等和不相等）
&（按位与）
^（按位异或）
|（按位或）
&&（逻辑与）
||（逻辑或）
=、+=、-=、*=、/=、%=、<<=、>>=、&=、^=、|=（赋值和复合赋值）
需要注意的是，虽然括号的优先级最高，但是在实际编程中，应该尽量避免过多的嵌套括号，以提高代码的可读性和可维护性。
167. 使用共用体变量,不可以(D).
(A).节省存储空间
(B).简化程序设计
©.进行动态管理
(D).同时访问所有成员
- 以下叙述正确的是(D).
(A).do-while语句构成的循环不能用其它语句构成的循环来代替.
(B).do-while语句构成的循环只能用break语句退出.
©.用do-while语句构成的循环,在while后的表达式为非零时结束循环.
(D).用do-while语句构成的循环,在while后的表达式为零时结束循环
169. 以下程序段 char *alp[]={“ABC”,“DEF”,“GHI”}; int j; puts(alp[1]);的输出结果是(D).
(A).A
(B).B
©.D
(D).DEF
char *alp[] = {"ABC", "DEF", "GHI"}; 定义了一个字符串指针数组，其中包含三个元素 "ABC"、"DEF" 和 "GHI"，每个元素都是一个字符串常量。
int j; 定义了一个整型变量 j，但未对其进行初始化。
puts(alp[1]); 输出 alp 数组中下标为 1 的元素。因为数组下标从 0 开始，所以 alp[1] 表示第二个元素，即字符串常量 "DEF"。puts() 函数用于输出字符串，并在末尾添加一个换行符。
因此，程序输出的结果是 "DEF"，并在末尾添加一个换行符。
- 在C语言中,int、char和short三种类型数据在内存中所占用的字节数(D).
(A).由用用户自己定义
(B).均为2个字节
©.是任意的
(D).由所用机器的机器字长决定
具体来说，根据 C 语言标准，int 类型至少应该占用 2 个字节，short 类型至少应该占用 2 个字节，char 类型至少应该占用 1 个字节。但是，具体占用的字节数还要考虑所用机器的机器字长和编译器的实现。
例如，在一些 16 位机器上，int 类型通常占用 2 个字节，short 类型也占用 2 个字节，char 类型占用 1 个字节。而在一些 32 位或者 64 位机器上，int 类型通常占用 4 个字节或者 8 个字节，short 类型通常占用 2 个字节，char 类型仍然只占用 1 个字节。
因此，由于不同的机器和编译器实现不同，int、char 和 short 三种类型数据在内存中所占用的字节数是由所用机器的机器字长决定的。
-
以下定义语句中,错误的是(D).
(A).int a[]={1,2};
(B).char *a[3];
©.char s[10]=“test”;
(D).int n=5,a[n]; -
putchar函数可以向终端输出一个(D).
(A).整型变量表达式值
(B).实型变量值
©.字符串
(D).字符或字符型变量值 -
以下不正确的叙述是(D).
(A).在C程序中所用的变量必须先定义后使用
(B).程序中,APH和aph是两个不同的变量
©.若a和b类型相同,在执行了赋值语句a=b;后b中的值将放入a中,b中的值不变
(D).当输入数值数据时,对于整型变量只能输入整型值;对于实型变量只能输入实型值
对于 C 语言中的变量类型，有整型、实型、字符型等。当输入数据时，可以采用强制类型转换的方式将一个类型的值转换成另一个类型的值。例如，可以通过 (int)x 的方式将实型变量 x 转换成整型变量，也可以通过 (float)y 的方式将整型变量 y 转换成实型变量。
因此，当输入数值数据时，也可以输入一个与变量类型不完全匹配的值，并通过强制类型转换的方式将其转换成相应的变量类型。例如，可以通过 scanf("%d",&x); 的方式将一个整型值赋给整型变量 x，也可以通过 scanf("%f",&y); 的方式将一个实型值赋给实型变量 y。
因此，选项 (D) 不正确。
174. 以下程序的输出结果是(D).
main()
{int i,j,k,a=3,b=2;
i=(- -a == b++)?- -a:++b;
j=a++;k=b;
printf(“i=%d,j=%d,k=%d\n”,i,j,k);
}
(A).i=2,j=1,k=3
(B).i=1,j=1,k=2
©.i=4,j=2,k=4
(D).i=1,j=1,k=3
初始化变量：a=3，b=2。
执行条件语句：i=(--a==b++)?--a:++b。
首先，将 a 减 1，a 的值变为 2。
然后，将 b 加 1，b 的值变为 3。
接着，比较 --a 和 b++ 的值。此时，--a 的值为 2，b++ 的值为 3。由于它们相等，条件判断为真，即 ( --a == b++ ) 的值为 1。
因为条件成立，执行 --a，将 a 的值减 1，a 的值变为 1。
将 --a 的结果赋值给 i，即 i=--a，i 的值为 1。
执行语句：j=a++。
首先，将 a 的值赋给 j，此时 j 的值为 1。
然后，将 a 加 1，a 的值变为 2。
执行语句：k=b，将 b 的值赋给 k，即 k=3。
输出结果：printf("i=%d,j=%d,k=%d\n",i,j,k)。
输出 i=1，因为 i 的值为 1。
输出 j=1，因为 j 的值为 a++ 执行前的 a 的值，即 1。
输出 k=3，因为 k 的值为 b 的值，即 3。
因此，这个程序的输出结果是 (D) i=1, j=1, k=3。
-
判断char型变量cl是否为小写字母的正确表达式是(D).
(A).‘a’<=cl<=‘z’
(B).(cl>=a)&&(cl<=z)
©.(‘a’>=cl)||(‘z’<=cl)
(D).(cl>=‘a’)&&(cl<=‘z’) -
以下程序的运行结果是(D).
main()
{
int i=1,sum=0;
while(i<10) sum=sum+1;i++;
printf(“i=%d,sum=%d”,i,sum);
}
(A).i=10,sum=9
(B).i=9,sum=9
©.i=2,sum=1
(D).运行不出结果
这段代码中存在错误。while循环的条件应该是i<10，然后在循环体内部应该对i进行递增操作i++，但是代码中将i++写在了循环体外面，导致循环体只会执行一次，然后无限循环。因此，程序会进入死循环，无法得到任何结果。
177. 下列关于C语言数据文件的叙述中正确的是(D).
(A).文件由ASCII码字符序列组成,C语言只能读写文本文件
(B).文件由二进制数据序列组成,C语言只能读写二进制文件
©.文件由记录序列组成,可按数据的存放形式分为二进制文件和文本文件
(D).文件由数据流形式组成,可按数据的存放形式分为二进制文件和文本文件
- C语言中表达逻辑"真"值的是(D).
(A)…T.
(B).0
©.True
(D).非0的数
179. 若调用fputc函数输出字符成功,则其返回值是(D).
(A).EOF
(B).1
©.0
(D).输出的字符
-
10下面有关 for 循环的正确描述是(D).
(A).for 循环只能用于循环次数已经确定的情况
(B).for 循环是先执行循环循环体语句,后判断表达式
©.在 for 循环中,不能用 break 语句跳出循环体
(D).for 循环的循环体语句中,可以包含多条语句,但必须用花括号括起来 -
若char a[10];已正确定义,以下语句中不能从键盘上给a数组的所有元素输入值的语句是(D).
(A).gets(a);
(B).scanf(“%s”,a);
©.for(i=0;i<10;i++)a[i]=getchar();
(D).a=getchar();
在 C 语言中，数组名不可以作为左值（即不能直接对数组赋值），因为它代表的是该数组首元素的地址。
选项 (D) 中的语句尝试将 getchar() 函数返回的值赋值给数组名 a，这是不合法的，会导致编译错误。
正确的输入数组的方法如下：
(A) gets(a)：使用 gets() 函数从标准输入流中读取一行字符串，并将其存储到 a 数组中，包括字符串末尾的空字符。
(B) scanf("%s",a)：使用 scanf() 函数从标准输入流中读取一个字符串，并将其存储到 a 数组中，遇到空格或换行符时停止读取，自动在字符串末尾添加空字符。
(C) for(i=0;i<10;i++) a[i]=getchar()：使用 getchar() 函数从标准输入流中逐个读取字符，并将其存储到 a 数组的每个元素中，包括空格、回车等不可打印字符。
因此，不能从键盘上给 a 数组的所有元素输入值的语句是 (D) a=getchar();。
182. fscanf函数的正确调用形式是(D).
(A).fscanf(fp,格式字符串,输出表列);
(B).fscanf(格式字符串,输出表列,fp);
©.fscanf(格式字符串,文件指针,输出表列);
(D).fscanf(文件指针,格式字符串,输入表列);
183. 下列语句的结果是(D).
main()
{ int j;
j=3;
printf(“%d,”,++j);
printf(“%d”,j++);
}
(A).3,3
(B).3,4
©.4,3
(D).4,4
首先，变量 j 被赋值为 3，然后在第一个 printf 语句中，使用前置递增运算符 ++j 对 j 进行递增操作，此时 j 的值变为 4。因此第一个 printf 语句输出结果为 4。
接着，在第二个 printf 语句中，使用后置递增运算符 j++ 对 j 进行递增操作，但是后置递增运算符会在整个表达式计算完毕后才进行递增，所以此时 j 的值仍然为 4。因此第二个 printf 语句输出结果也为 4。
因此，最终的结果是 4, 4。选项 (D) 4, 4 是正确的。