C语言题库--选择题A篇

---

1. 以下数据中,不正确的数值或字符常量是(A).
   (A).c
   (B).66
   ©.0xaa
   (D).50

在C语言中，字符常量是用单引号括起来的单个字符，如 'a'、'b'、'0' 等。而数值常量则没有单引号。
根据这个规则，我们来分析给出的选项：
(A).c - 这个不是有效的字符常量，因为它只有一个字符，但这个字符不是有效的字符表示。
(B).66 - 这是一个有效的数值常量。
(C).0xaa - 这也是一个有效的数值常量，它是一个十六进制数。
(D).50 - 这是一个有效的数值常量。

2. 设j和k都是int类型,则for循环语句：
   for(j=0,k=0;j<=9&&k!=876;j++)
   scanf(“%d”,&k);（A）
   (A).最多执行10次
   (B).最多执行9次
   ©.是无限循环
   (D).循环体一次也不执行

3. char a1[]=“abc”,a2[80]=“1234”;将a1串连接到a2串后面的语句是(A).
   (A).strcat(a2,a1);
   (B).strcpy(a2,a1);
   (C ).strcat(a1,a2);
   (D).strcpy(a1,a2);

4. 以下正确的说法是:在C语言中(A).
   (A).实参和与其对应的形参各占用独立的存储单元
   (B).实参和与其对应的形参共占用一个存储单元
   ©.只有当实参和与其对应的形参同名时才共占用存储单元
   (D).形参是虚拟的,不占用存储单元

5. 下列字符序列中,是C语言保留字的是(A).
   (A).sizeof
   (B).include
   ©.scanf
   (D).sqrt

(A).sizeof - 是C语言的保留字，用于获取变量或数据类型的大小。
(B).include - 不是C语言的保留字，而是预处理指令，用于包含头文件。
(C).scanf - 不是C语言的保留字，而是标准库函数，用于从标准输入读取格式化数据。
(D).sqrt - 不是C语言的保留字，而是标准库函数，用于计算平方根。
所以，正确答案是：(A).sizeof。

6. 以下选项中,与k=n++完全等价的表达式是(A).
   (A).k=n,n=n+1
   (B).n=n+1,k=n
   ©.k=++n
   (D).k+=n+1

k=n++是先把n赋给k之后n再自增一

7. 在位运算中,操作数每左移一位,其结果相当于(A).
   (A).操作数乘以2
   (B).操作数除以2
   ©.操作数除以4
   (D).操作数乘以4

在位运算中，左移操作是将二进制位向左移动指定的位数，右边空出的位用0来填充。
对于一个二进制数，每左移一位，相当于该数乘以2。
因此，操作数每左移一位，其结果相当于操作数乘以2。
所以正确答案是：(A).操作数乘以2。

8. 以下程序的运行结果是(A).
   main()
   { int n;
   for(n=1;n<=10;n++)
   {
   if(n%3==0) continue;
   printf(“%d”,n);
   }
   }
   (A).12457810
   (B).369
   ©.12
   (D).1234567890

在循环体中，有一个if语句，判断n是否能被3整除，如果能被3整除，则执行continue语句，跳过本次循环，进入下一次循环。
因此，当n为3的倍数时，不会被打印出来。
所以，程序的运行结果是12457810。

9. int a=1,b=2,c=3;if(a>b)a=b;if(a>c)a=c;则a的值为(A).
   (A).1
   (B).2
   (C ).3
   (D).不一定

10. 下列定义数组的语句中正确的是(A).
    (A).#define size 10 char str1[size],str2[size+2];
    (B).char str[];
    ©.int num[‘10’];
    (D).int n=5; int a[n][n+2];

(A). #define size 10 char str1[size],str2[size+2];
这个语句中，#define 是预处理指令，用于定义宏。size 是宏的名字，10 是它的值。然后定义了两个字符数组 str1 和 str2。这里没有语法错误，所以这个语句是正确的。
(B). char str[];
这个语句是不完整的。数组的大小没有被指定，所以编译器不知道数组应该有多大。这是一个错误的语句。
©. int num[‘10’];
在C语言中，数组大小的语法是使用正整数，而不是用单引号括起来的字符常量。因此，这个语句是错误的。
(D). int n=5; int a[n][n+2];
这个语句定义了一个二维数组 a，其大小由变量 n 确定。在C99标准之前，这种动态大小的数组是不允许的。因此，这个语句在某些编译器上可能是错误的。
综上所述，只有选项(A)是正确的数组定义语句。

11. C语言中运算对象必须是整型的运算符是(A).
    (A).%=
    (B)./
    ©.=
    (D).〈=

取模运算符`%`要求其运算对象必须是整型，因为取模运算的结果是一个整数。

12. C语言中 while 和 do-while 循环的主要区别是(A).
    (A).do-while 的循环体至少无条件执行一次
    (B).while的循环控制条件比 do-while的循环控制条件更严格
    ©.do-while 允许从外部转到循环体内
    (D).do-while 的循环体不能是复合语句

13. 16.在C语言中,形参的缺省存储类别是(A).
    (A).auto
    (B).register
    ©.static
    (D).extern

14. 从键盘上输入某字符串时,不可使用的函数是(A).
(A).getchar()
(B).gets()
©.scanf()
(D).fread()

在C语言中，从键盘上输入字符串时，可以使用以下函数：
(B).gets()
(C).scanf()
但是，gets()函数已被认为是不安全的，因为它可能导致缓冲区溢出。因此，更推荐使用fgets()函数代替gets()。
(D).fread() 通常用于从文件读取数据，而不是从键盘。
所以，不可使用的函数是 (A).getchar()，因为它只用于逐个字符地读取输入。

15. 以下数据中,不正确的数值或字符常量是(A).
    (A).8.9e1.2
    (B).10
    ©.0xff00
    (D).82.5

(A)e后面的指数部分只能是一个整数常量

16. 以下不是无限循环的语句为(A).
    (A).for(y=0,x=1;x>++y;x=i++) i=x;
    (B).for(;;x++=i);
    ©.while(1){x++;}
    (D).for(i=10;;i–) sum+=i;

(A). for(y=0,x=1;x>++y;x=i++) i=x;
这个循环中，初始条件 `y=0, x=1` 已经使得循环体 `x>++y` 为假，因此这个循环不会执行。
(B). for(;;x++=i);
这是一个无限循环，因为它的条件部分是空的（`;;`），并且没有提供终止条件。
(C). while(1){x++;}
这是一个无限循环，因为它的条件是 `1`，即永远为真。
(D). for(i=10;;i--) sum+=i;
这是一个无限循环，因为它的条件部分是空的（`;;`），并且没有提供终止条件。
根据上述分析，选项 (A) 不是无限循环。所以答案是 (A)。

17. while(fabs(t)<1e-5)if(!s/10)break;循环结束的条件是(A).
(A).t>=1e-5&&t<=-1e-5
(B).fabs(t)<1e-5&&!s/10
©.fabs(t)<1e-5
(D).s/10 == 0

18. 以下叙述中正确的是(A).
    (A).构成C程序的基本单位是函数
    (B).可以在一个函数中定义另一个函数
    ©.main()函数必须放在其它函数之前
    (D).所有被调用的函数一定要在调用之前进行定义

19. 函数 rewind 的作用是(A).
(A).使位置指针重新返回文件的开头
(B).将位置指针指向文件中所要求的特定位置
©.使位置指针指向文件的末尾
(D).使位置指针自动移至下一个字符位置

(A) 使位置指针重新返回文件的开头 - 对应的是 `rewind` 函数。
(B) 将位置指针指向文件中所要求的特定位置 - 对应的是 `fseek` 函数。
(C) 使位置指针指向文件的末尾 - 对应的是 `fseek` 函数，通过设置偏移量为0，起始位置为`SEEK_END`。
(D) 使位置指针自动移至下一个字符位置 - 这并不是一个标准的C语言文件操作函数的功能。通常，当你从文件中读取一个字符后，位置指针会自动移至下一个字符位置。

20. C语言程序中,当调用函数时(A).
    (A).实参和虚参各占一个独立的存储单元
    (B).实参和虚参可以共用存储单元
    ©.可以由用户指定是否共用存储单元
    (D).计算机系统自动确定是否共用存储单元

21. 当定义一个结构体变量时,系统分配给它的内存是(A).
    (A).各成员所需内存量的总和
    (B).结构中第一个成员所需内存量
    ©.结构中最后一个成员所需内存量
    (D).成员中占内存量最大者所需的容量

22. 下列变量定义中合法的是(A).
(A).short _a=1-.1e-1;
(B).double b=1+5e2.5;
©.long do=0xfdaL;
(D).float 2_and=1-e-3;

合法的变量定义是 (A) short _a=1-.1e-1。

原因是，选项 (A) 中的变量定义使用了合法的语法并且没有命名冲突。其中，short _a 声明了一个短整型变量 _a，并将其初始化为 1-.1e-1 的结果。这个表达式的结果是一个浮点数，但是由于赋值给了一个短整型变量，会进行隐式类型转换。

选项 (B) 中的变量定义 double b=1+5e2.5 使用了非法的语法，指数部分 2.5 不符合浮点数的表示规范。

选项 (C) 中的变量定义 long do=0xfdaL 使用了关键字 do 作为变量名，而 do 是 C 语言中的保留字，不能作为变量名。

选项 (D) 中的变量定义 float 2_and=1-e-3 使用了非法的变量名 2_and，变量名不能以数字开头。

因此，只有选项 (A) 是合法的变量定义。

23. 若有说明语句:char c=‘\72’;则变量c(A).
    (A).包含1个字符
    (B).包含2个字符
    ©.包含3个字符
    (D).说明不合法,c的值不确定

首先，我们需要了解ASCII码。在ASCII码中，'\72'对应的十进制值为72，对应的字符是'H'。
现在，我们根据给定的说明语句进行分析：
char c='\72';
这是一个简单的字符声明和初始化。在这里，我们声明了一个字符变量`c`并给它赋了一个初始值，即ASCII码为72的字符，也就是'H'。
所以，变量`c`只包含一个字符，即'H'。
因此，答案是：(A). 包含1个字符。

24. 结构体类型的定义允许嵌套是指(A).
    (A).成员是已经或正在定义的结构体型
    (B).成员可以重名
    ©.结构体型可以派生
    (D).定义多个结构体型

25. 先用语句定义字符型变量c,然后要将字符a赋给c,则下列语句中正确的是(A).
    (A).c=‘a’;
    (B).c=“a”;
    ©.c=“97”;
    (D).C=‘97’

26. 下列数组说明中,正确的是(A).
    (A).static char str[]=“China”;
    (B).static char str[]; str=“China”;
    ©.static char str1[5],str2[]={“China”}; str1=str2;
    (D).static char str1[],str2[];str2={“China”}; strcpy(str1,str2);

(A) `static char str[]="China";`
这个声明是正确的。`static` 关键字表示该数组的生命周期是整个程序的执行期间，而不是只在定义它的代码块内。同时，`str[]` 表示这是一个字符数组，并且它被初始化为 "China"。
(B) `static char str[]; str="China";`
这个声明是不完整的。首先，`static char str[];` 只是声明了一个静态字符数组，但没有指定其大小。然后，`str="China";` 试图给数组赋值，但因为数组的大小未知，所以这是不正确的。
(C) `static char str1[5],str2[]={"China"}; str1=str2;`
这个声明也是不正确的。首先，`str1` 被初始化为一个包含5个字符的数组，但 `str2` 是一个字符数组，其大小未知（因为它是通过初始化列表来初始化的）。然后，`str1=str2;` 试图将 `str2` 的内容复制到 `str1`，但由于 `str1` 和 `str2` 的大小可能不同，所以这是不允许的。
(D) `static char str1[],str2[]; str2={"China"}; strcpy(str1,str2);`
这个声明也是不正确的。首先，`static char str1[],str2[];` 只是声明了两个静态字符数组，但没有指定它们的大小。然后，`str2={"China"};` 试图给 `str2` 赋值，但由于 `str2` 的大小未知，这是不正确的。最后，`strcpy(str1,str2);` 试图将 `str2` 的内容复制到 `str1`，但由于 `str1` 和 `str2` 的大小都是未知的，所以这也是不允许的。
综上所述，只有选项 (A) 是正确的数组声明和初始化。

27. 若有int *p=(int *)malloc(sizeof(int));则向内存申请到内存空间存入整数123的语句为(A).
(A).scanf(“%d”,p);
(B).scanf(“%d”,&p);
©.scanf(“%d”,*p);
(D).scanf(“%d”,**p);

首先，需要理解指针和内存分配的概念。

int *p = (int *)malloc(sizeof(int)); 这行代码的意思是：我们声明了一个指向整数的指针 p，并使用 malloc 函数为它分配了足够的内存来存储一个整数。

scanf("%d", p); 这行代码的意思是：我们使用 scanf 函数从标准输入读取一个整数，并存储到指针 p 所指向的内存位置。
分析选项：
(A) scanf("%d", p); - 这是正确的。我们使用 scanf 函数从标准输入读取一个整数，并存储到指针 p 所指向的内存位置。
(B) scanf("%d", &p); - 这是不正确的。&p 返回的是指针 p 的地址，而不是它所指向的变量的地址。
© scanf("%d", *p); - 这是不正确的。*p 解引用指针 p，得到它所指向的值（即整数），而不是它所指向的地址。
(D) scanf("%d", **p); - 这也是不正确的。首先，*p 解引用指针 p，得到它所指向的值（即整数）。然后，**p 是对整数的再次解引用，这是不合法的。
所以，正确答案是 (A) scanf("%d", p);。

28. 以下叙述中正确的是 (A).
    (A).C程序中注释部分可以出现在程序中任意合适的地方
    (B).花括号"{“和”}"只能作为函数体的定界符
    ©.构成C程序的基本单位是函数,所有函数名都可以由用户命名
    (D).分号是C语句之间的分隔符,不是语句的一部分

29. 执行下面程序后,输出结果是(A).
    main()
    { int a=45,b=27,c=0;
    c=max(a,b);
    printf(“%d\n”,c);
    }
    int max(int x,int y)
    { int z;
    if(x>y) z=x;
    else z=y;
    return(z);
    }
    (A).45
    (B).27
    ©.18
    (D).72

首先，它定义了一个`max`函数，该函数接收两个整数作为参数，并返回其中的最大值。
然后，在`main`函数中，我们有两个整数`a`和`b`，分别为45和27。
我们调用`max`函数，并将结果赋值给变量`c`。
最后，我们打印出`c`的值。
逐步分析：
1. `a`和`b`的值分别为45和27。
2. 我们调用`max(a, b)`，即`max(45, 27)`。
3. 在`max`函数中，我们比较`x`和`y`的值。因为45大于27，所以返回45。
4. `c`被赋值为45。
5. 最后，我们打印出`c`的值，即45。
所以，输出结果是(A). 45。

30. 设有以下语句, 若0 char str[4][2]={“aaa”,“bbb”,“ccc”,“ddd”},*strp[4];
    int j;
    for (j=0;j<4;j++)
    strp[j]=str[j];
    (A).strp
    (B).str[k]
    ©.strp[k]
    (D).*strp

代码定义了一个二维字符数组 str 和一个指向字符的指针数组 strp。

char str[4][2]={"aaa","bbb","ccc","ddd"},*strp[4];
这里，str 是一个 4x2 的二维字符数组，即有 4 行，每行 2 个字符。而 strp 是一个包含 4 个元素的指针数组，每个元素都是指向字符的指针。
接下来，通过循环将 str 中的每个字符串的首地址赋给 strp：
int  j;
for (j=0;j<4;j++)
strp[j]=str[j];
看选项：
(A) strp：这是一个指针数组的名称，它本身并不指向任何有效的内存地址，所以引用它是非法的。
(B) str[k]：这是对二维字符数组 str 的合法引用，其中 0 <= k < 4。
© strp[k]：这是对指针数组 strp 的合法引用，其中 0 <= k < 4。注意，这里的 strp[k] 实际上就是 *(strp + k)，它指向的是 str 中的第 k 个字符串的首地址。
(D) *strp：这是对指针数组 strp 的第一个元素的解引用，它是合法的。
综上所述，选项 (A) 是对字符串的非法引用。

31. 以下语句中,循环次数不为10次的语句是(A).
    (A).for(i=1;i<10;i++);
    (B).i=1;do{i++;}while(i<=10);
    ©.i=10;while(i>0){–i;}
    (D).i=1;m:if(i<=10){i++;goto m;}

32. 以下不能正确进行字符串赋初值的语句是(A).
    (A).char str[5]=“good!”;
    (B).char str[]=“good!”;
    ©.char *str=“good!”;
    (D).char str[5]={‘g’,‘o’,‘o’,‘d’};

33. 若有double *p,x[10];int i=5;使指针变量p指向元素x[5]的语句为(A).
    (A).p=&x[i];
    (B).p=x;
    ©.p=x[i];
    (D).p=&(x+i)

34. C语言的if语句嵌套时,if与else的配对关系是(A).
    (A).每个else总是与它上面的最近的并且尚未与其他else匹配的if配对
    (B).每个else总是与最外层的if配对
    ©.每个else与if的配对是任意的
    (D).每个else总是与它上面的if配对

35. 以下正确的函数定义形式是(A).
    (A).double fun(int x,int y)
    (B).double fun(int x;int y)
    ©.double fun(int x,int y);
    (D).double fun(int x,y);

36. 经过下列的语句 int j,a[10],*p;定义后,下列语句中合法的是(A)
    (A).p=a+2;
    (B).p=a[5];
    ©.p=a[2]+2;
    (D).p=&(j+2);

37. enum a {sum=9,mon=-1,tue};2char a[]=“This is a program.”;输出前5个字符的语句是(A).
    (A).printf(“%.5s”,a);
    (B).puts(a);
    ©.printf(“%s”,a);
    (D).a[5*2]=0;puts(a);

(A). `printf("%.5s",a);`
这个语句使用`printf`函数来打印字符串。`%.5s`是一个格式说明符，表示只打印字符串的前5个字符。
(B). `puts(a);`
这个语句使用`puts`函数来打印字符串。它会打印整个字符串，直到遇到空字符（'\0'）。
(C). `printf("%s",a);`
这个语句使用`printf`函数来打印整个字符串。
(D). `a[5*2]=0;puts(a);`
这个语句首先将字符串的第10个位置设置为空字符（'\0'），然后使用`puts`函数打印整个字符串。
根据题目要求，我们需要输出字符串的前5个字符。所以，正确的选项是：
(A). `printf("%.5s",a);`