C语言选择题

1. 按照标识符的要求，（A）不能组成标识符。

     A.连接符

     B.下划线

     C.大小写字母

     D.数字字符

在大多数编程语言中，标识符通常由字母（包括大写和小写）、数字和下划线组成，但不能以数字开头，并且不能包含连接符等特殊字符。

2. 在C语言中，数字029是一个（D）。

     A.八进制数

     B.十进制数

     C.十六进制数

     D.非法数

八进制数以数字 0 开头，但八进制数的数字只能是 0 - 7 。

十进制数就是我们平常使用的普通数字，不需要前缀。

 
十六进制数以 0x 或 0X 开头。

 
例如，八进制数 027 是合法的，十进制数 29 直接写为 29 ，十六进制数 0x1D 是合法的。所以 029 是一个非法数

3. 若有char w; int x; float y; double z; 则表达式w*x+z-y值的数据类型为（D）。

     A.float

     B.char

     C.int

     D.double

在 C 语言中，当进行混合运算时，运算结果的类型会自动转换为参与运算的操作数中精度最高的类型.

4. 在c语言中，不允许有常量的数据类型是（B）

     A.整型

     B.结构型

     C.字符型

     D.字符串

结构体是一种自定义的数据类型，通常用于组合不同类型的数据来创建更复杂的数据结构，但结构体本身不能直接作为常量。结构体的变量可以有常量的值，但结构体类型不能直接表示为常量。

5. 下列运算符中优先级最低的是  (A)

     A.  II

     B.  >=

     C.  !=

     D.  ~

 在 C 语言中，逻辑或运算符“||”的优先级低于关系运算符“>=”和“!=”，按位取反运算符“~”是单目运算符，优先级较高。关系运算符“>=”和“!=”的优先级相同。

 
例如，对于表达式 a >= b || c!= d ，会先计算关系运算 a >= b 和 c!= d ，然后再进行逻辑或运算。

6. 若x为浮点型，则表达式x=10/4为（B）。

     A.  2.5

     B.  2.0

     C.  2

     D.  3

在 C 语言中，当整数相除（10/4）时，结果会进行整数除法，得到的结果是整数 2 。

之后将这个整数 2 赋值给浮点型变量 x 时，会进行类型转换，将整数 2 转换为浮点数 2.0 。例如，如果后续对 x 进行输出，使用 printf("%f", x); 输出的结果将是 2.000000 。

7. 逻辑运算符两侧运算对象的数据类型（D）。

     A. 只能是 0 或 1

     B. 只能是 0 或非 0 正数

     C. 只能是整型或字符型的数据

     D. 可以是任何类型的数据

逻辑运算符包括 &&（逻辑与）、||（逻辑或）和 !（逻辑非）

对于逻辑与 && 和逻辑或 || ，其操作数会被隐式转换为布尔值（非零值被视为 true ，零值被视为 false ）进行运算.

所以逻辑运算符两侧运算对象的数据类型可以是任意类型.

8. 若p1、p2都是整型指针，p1已经指向变量x，要使p2也指向x, (A)是正确的。  (重点)

     A.  p2 = p1;

     B.  p2 = **p1;

     C.  p2 = &p1;

     D.  p2 = *p1;

在 C 语言中，指针变量存储的是另一个变量的地址。

 
当 p1 已经指向变量 x 时，要使 p2 也指向 x ，只需要将 p1 所存储的地址赋值给 p2 即可。

选项 C 中，&p1 是取 p1 这个指针变量本身的地址，而不是 x 的地址。

选项 D 中，*p1 是获取 p1 所指向变量的值，不是地址。

 
例如，如果有 int x = 5; int *p1 = &x; ，执行 p2 = p1; 后，对 *p2 的操作就等同于对 *p1 和 x 的操作。

9. 以下选项中，对基本类型相同的指针变量不能进行运算的运算符是（A）。

     A. +

     B. -

     C. =

     D. ==

在 C 语言中，对于基本类型相同的指针变量，可以进行减法运算（-），用于计算两个指针之间的元素个数差。

 
可以进行赋值运算（=），将一个指针的值赋给另一个指针。

 
可以进行比较运算（==），判断两个指针是否指向相同的地址。

 
但是不能进行加法运算（+），因为指针的加法运算在 C 语言中没有明确的语义和定义。

10. int a=5,*ap=&a ;则下列表达式错误的是（D）     （重点）

     A.  &*ap 相当于&a

     B.  *&a 相当于ap

     C.  (*ap)++ 相当于a++

     D.  *ap++ 是合法访问

选项 A 中，&*ap ，先进行 *ap 得到 a ，再对其取地址就是 &a ，所以该表达式正确。

 
选项 B 中，*&a ，先对 a 取地址得到 &a ，再进行解引用就是 a ，与 ap 所指向的内容相同，所以该表达式正确。

 
选项 C 中，(*ap)++ ，先解引用得到 a ，然后对 a 进行自增，相当于 a++ ，所以该表达式正确。

 
选项 D 中，*ap++ 是错误的，它的本意可能是先使用 *ap 的值，然后让 ap 指针自增。但由于运算符优先级的问题，这个表达式会先计算 ap++ ，即让指针 ap 自增，然后再进行解引用，这不是预期的操作，所以该表达式错误。

 
例如，如果按照错误的方式使用 *ap++ ，可能会导致程序出现未定义的行为或错误的结果

11. 下面是对s的初始化，其中不正确的是（D）

     A. char s[5]={"abc"};

     B. char s[5]={'a', 'b', 'c'};

     C. char s[5]="";

     D. char s[5]="abcdef";

选项 A ，char s[5] = {"abc"}; ，数组长度为 5，初始化字符串 "abc" ，剩余两个位置自动补 '\0' ，是正确的。

 
选项 B ，char s[5] = {'a', 'b', 'c'}; ，这种初始化方式没有自动添加字符串结束符 '\0' ，但在数组长度范围内，也是可以的。

 
选项 C ，char s[5] = ""; ，初始化一个空字符串，剩余位置自动补 '\0' ，是正确的。

 
选项 D ，char s[5] = "abcdef"; ，初始化的字符串长度超过了数组的定义长度，会导致越界，是不正确的。

 
例如，如果定义 char s[7] = "abcdef"; ，就是正确的初始化。

12. 若有int x=1;，执行下列程序段后，变量x的正确结果是：（D）

     A. 1

     B. 2

     C. 3

     D. 4

在这个 switch 语句中，x * 10 的值为 10 。

首先会匹配到 case 10 ，执行 x += 1 ，此时 x 的值变为 2 。由于没有 break 语句，会继续执行下面的 case 11 和 default 中的语句，分别再次执行 x += 1 。所以经过这一系列操作后，x 的值最终变为 4 

13. 下列程序段的功能是（D）

     A. 自然数1~9的累加和

     B. 自然数1~10的累加和

     C. 自然数1~9中的奇数之和

     D. 自然数1~10中的偶数之和

在这个程序中，for 循环的条件是 i < 10 ，且 i 的步长为 2 ，即 i 依次取值为 1、3、5、7、9 。

 
在循环体中，进行累加的是 i + 1 ，即 2、4、6、8、10 。

 
所以这个程序段的功能是计算自然数 1 到 10 中的偶数之和。

例如，如果将循环体修改为 s += i ，那么就是计算自然数 1 到 9 中的奇数之和。

 14. 对于 C/C++语言的函数，下列叙述中正确的是（A）。

     A. 函数的定义不能嵌套，但函数调用可以嵌套

     B. 函数的定义可以嵌套，但函数调用不能嵌套

     C. 函数的定义和调用都不能嵌套

     D. 函数的定义和调用都可以嵌套

在 C/C++语言中，函数的定义不能嵌套，也就是说不能在一个函数的定义内部再定义另一个函数。但是函数的调用是可以嵌套的，即在一个函数内部可以调用其他函数，被调用的函数内部还可以再调用其他函数。

15. 在一个被调用函数中，关于 return 语句使用的描述，错误的是（D）。

     A. 被调用函数中可以不用 return 语句

     B. 被调用函数中可以使用多个 return 语句

     C. 被调用函数中，如果有返回值，就一定要有 return 语句

     D. 被调用函数中，一个 return 语句可以返回多个值给调用函数

选项 A ，被调用函数中可以不用 return 语句，例如当函数不需要返回值时。

 
选项 B ，被调用函数中可以使用多个 return 语句，根据不同的条件在不同的位置返回。

 
选项 C ，被调用函数中，如果有返回值，就一定要有 return 语句来返回具体的值。

 
选项 D ，一个 return 语句只能返回一个值给调用函数，不能返回多个值。

 
例如，一个计算两个数之和的函数，如果要返回结果，就需要使用 return a + b; 这样的语句来返回一个值。

 16. 若程序中定义了以下函数

double myadd(double a,double b)
{ return (a+b); }
并将其放在调用语句之后，则在调用之前应该对该函数进行说明， 以下选项中错误的说明是(A)。

     A.  double myadd(double a,b) ;

     B.  double myadd(double,double);

     C.  double myadd(double b,double a);

     D.  double myadd(double x,double y);

在函数声明中，每个参数都必须明确指定其类型，不能像选项 A 中那样只指定第一个参数的类型而省略第二个参数的类型。

 
选项 B 、C 、D 都是正确的函数声明方式，只要参数的类型正确，参数的名称可以与定义中的不同。

 
例如，如果函数调用时传递的参数类型与声明不一致，可能会导致编译错误。

17. 若有函数max(a,b)，为了让函数指针变量p指向函数max，正确的赋值方式是（A）。

     A. p=max;

     B. *p=max;

     C. p=max(a,b);

     D. *p=max(a,b);

 在 C 语言中，要让函数指针变量 p 指向函数 max ，应该使用 p = max; 这种赋值方式。

 
选项 B 中，*p = max; 这种写法是错误的，不能通过解引用的方式给函数指针赋值。

 
选项 C 中，p = max(a,b); 这是调用函数 max 并将返回值赋给 p ，而不是让 p 指向函数 max 。

 
选项 D 中，*p = max(a,b); 同样是错误的写法，不能对函数指针进行这样的操作。

 
例如，如果后续通过 p 来调用函数 max ，可以写成 (*p)(a, b);

18. 若有函数int func(int a,int b)，函数指针变量p已经指向func函数，那么下列用指针方式调用函数的正确方法是(C)。

     A.  (*p)func(2,3);

     B.  *func(2,3);

     C.  p(2,3);

     D.  *p(2,3);

当函数指针变量 p 已经指向函数 int func(int a, int b) 时，用指针方式调用函数的正确方法是 p(2, 3) 。

 
选项 A 中，(*p)func(2, 3) 这种写法是错误的，不能在函数指针前再加 * 然后跟函数名。

 
选项 B 中，*func(2, 3) 这种写法是错误的，不能直接对函数名使用解引用操作。

 
选项 D 中，*p(2, 3) 这种写法也是错误的。

19.  若有以下定义和语句:

int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;
则不能表示a数组元素的表达式是（B）

     A. *p

     B. a[10]

     C. *a

     D. a[p-a]

选项 A ，*p ，因为 p 指向数组 a 的首元素，所以 *p 能表示数组 a 的第一个元素。

 
选项 B ，a[10] ，数组 a 的有效下标是 0 到 9 ，a[10] 超出了数组的范围，是错误的表达式。

 
选项 C ，*a ，等同于 a[0] ，能表示数组 a 的第一个元素。

 
选项 D ，a[p - a] ，因为 p 指向 a 的首元素，所以 p - a 的值为 0 ，a[p - a] 就等同于 a[0] ，能表示数组 a 的第一个元素。

20. 若已定义：

int a[9]，*p=a；
并在以后的语句中未改变p的值，不能表示a[1] 地址的表达式是（C）

     A. p+1

     B. a+1

     C. a++

     D. ++p

 选项 A ，p + 1 ，因为 p 是指向 int 类型的指针，p + 1 表示指向数组 a 中下一个元素（即 a[1] ）的地址。

 
选项 B ，a + 1 ，数组名 a 本身代表数组的首地址，a + 1 表示数组中第二个元素（即 a[1] ）的地址。

 
选项 C ，数组名 a 是一个地址常量，不能进行自增（a++ ）操作，这样的表达式是错误的。

 
选项 D ，++p ，使 p 指向下一个元素（即 a[1] ）的地址。

 
例如，如果要通过指针访问 a[1] 的值，可以使用 *(p + 1) 或者 *(a + 1) 。

21. 以下数组定义中错误的是（B）。

     A. int x[][3]={0};

     B. int x[2][3]={{1,2},{3,4},{5,6)};

     C. int x[][3]={{1,2,3},(4,5,6)};

     D. int x[2][3]={1,2,3,4,5,6};

对于二维数组 int x[2][3] ，初始化时应该提供两行数据，每行包含三个元素。

选项 A ，int x[][3]={0}; ，可以这样初始化，未明确指定行数，根据后面的初始化值可以推断出行数。

选项 C ，int x[][3]={{1, 2, 3}, {4, 5, 6}}; ，初始化方式正确。

选项 D ，int x[2][3]={1, 2, 3, 4, 5, 6}; ，按顺序初始化数组元素，方式正确。

22. 有两个字符数组a,b，则以下正确的输入语句是（B）

     A. gets(a,b);

     B. scanf("%s%s",a,b);

     C. scanf("%s%s",&a,&b);

     D. gets("a"),gets("b");

选项 A ，gets 函数一次只能接受一个字符串的输入，不能同时输入两个字符串，所以 gets(a, b) 是错误的。

 选项 B ，scanf("%s%s", a, b) 是正确的输入格式，可以依次输入两个字符串分别存储到数组 a 和 b 中。

 选项 C ，数组名本身就代表数组的首地址，不需要再使用取地址符 & ，所以 scanf("%s%s", &a, &b) 是错误的。

 选项 D ，gets 函数的参数应该是字符数组名，而不是字符串 "a" 和 "b" ，所以 gets("a"), gets("b") 是错误的。

 例如，如果输入 hello world ，那么 a 中存储 hello ，b 中存储 world 。

23. 下面的程序段将输出 （C） 。

char s[10] = "abcd";
printf("%d\n", sizeof(s));
    A. 4

    B. 5

    C. 10

    D. 11

sizeof 操作符用于获取变量或数据类型所占的字节数。对于数组，sizeof 返回的是数组分配的总字节数。

24. 设有数组定义：char array [ ]="China"; 则数组 array所占的空间为（C）。

     A. 4个字节

     B. 5个字节

     C. 6个字节

     D. 7个字节

字符串 "China" 包含 5 个字符 'C'、'h'、'i'、'n'、'a'，但在 C 语言中，字符串会以 '\0' 作为结束标志。

所以数组 array 实际存储的是 "China\0" ，共 6 个字符。

 每个字符占用 1 个字节，所以数组 array 所占的空间为 6 个字节。

 例如，如果定义 char array[] = "Hello" ，那么数组实际存储的是 "Hello\0" ，占用 6 个字节。

25.  对于以下定义，不正确的叙述是（B）。

struct  ex { 
  int x;
  float y;
  char z ;
} example;
     A. struct是定义结构类型的关键字

     B. example是结构类型名

     C. x, y, z都是结构成员名

     D. struct ex是结构类型名

 struct ex 是结构类型名，example 是使用 struct ex 定义的结构变量名，而不是结构类型名。