C语言编程易错题合集--超全解析持续更新中

本篇主要收集常见C语言易错题，并附答案解析，持续更新中。

老铁们，创作不易，先赞后看养成习惯，你的支持是对我更新最大的鼓励！

一、选择题

1.关于C语言关键字说法正确的是：( )

A.关键字可以自己创建

B.关键字不能自己创建

C.关键字可以做变量名

D.typedef不是关键字

答案解析：

  C语言关键字：C语言定义的，具有特定含义、专门用于特殊用途的C语言标识符，也称为保留字

  A：错误，关键字是语言自身定义的

  B：正确

  C：错误，关键字具有特殊含义，不能作为变量名

  D：错误，typedef是用来给类型取别名的关键字

  因此，选择B

2.关于static说法不正确的是：（ ）

A.static可以修饰局部变量

B.static可以修全局变量

C.static修饰的变量不能改变

D.static可以修饰函数

答案解析：

本题主要考察static的特性

  1. static修饰变量

   a. 函数中局部变量：

      声明周期延长：该变量不随函数结束而结束

      初始化：只在第一次调用该函数时进行初始化

      记忆性：后序调用时，该变量使用前一次函数调用完成之后保存的值

      存储位置：不会存储在栈上，放在数据段

   b. 全局变量

     改变该变量的链接属性，让该变量具有文件作用域，即只能在当前文件中使用

   c. 修饰变量时，没有被初始化时会被自动初始化为0

  2. static修饰函数

   改变该函数的链接属性，让该函数具有文件作用域，即只能在当前文件中使用

  A：正确，原因参考上述注解

  B：正确，原因参考上述注解

  C：错误，const修饰的变量不能改变

  D：正确，原因参考上述注解

  因此：选择C

3.下面那个不是转义字符？

A.'\n'

B.'\060'

C.'\q'

D.'\b'

答案解析：

A：'\n' 转义字符，代表换行

B：'\060' 转义字符，060八进制数据，十进制为48，表示ASCII码为48的'0'

C：'\q' 什么都不是

D：'\b' 转义字符，表示退格

因此：选择C

4.下面程序的结果是:（ ）

#include <stdio.h>
#include <string.h>
int main()
{
    printf("%d\n", strlen("c:\test\121"));
    return 0;
}

A.7

B.8

C.9

D.10

答案解析：

strlen：获取字符串的有效长度，不包括'\0'

"c:\test\121": 在该字符串中，\t是转移字符，水平制表，跳到下一个tab的位置；而\121表示一个字符，是讲121看做8进制数组，转换为10进制后的81，作业为ASCII码值的字符，即：字符'Q' ，故上述字符串实际为："c:  estQ",只有7个有效字符

因此：选择A

5.下面代码的结果是：( )

#include <stdio.h>
#include <string.h>

int main()
{
    char arr[] = {'b', 'i', 't'};
    printf("%d\n", strlen(arr));
	return 0;
}

A.3

B.4

C.随机值

D.5

 答案解析：

strlen是用来获取字符串的有效长度的，结尾标记'\0'不包含在内。

strlen获取的规则非常简单：从前往后依次检测，直到遇到'\0'是就终止检测。

而上题中arr是一个字符数组，不是一个有效的字符串，因为后面没有放置'\0'，因此strlen在求解时，将有效字符检测完之后，还会继续向后检测，直到遇到'\0'是才终止，因此答案为不确定，就看紧跟在't'之后的第一个'\0'在什么位置。

因此：答案选C

6.下面代码的执行结果是什么（ ）

#include <stdio.h>
int main() {
	int x = 3;
	int y = 3;
	switch (x % 2) {
	case 1:
		switch (y)
		{
		case 0:
			printf("first");
		case 1:
			printf("second");
			break;
		default: printf("hello");
		}
	case 2:
		printf("third");
	}
	return 0;
}

A.secondthird

B.hello

C.firstsecond

D.hellothird

  switch语句时多分支的选择语句，switch中表达式结果命中那个case，就执行该case子项，如果case子项后没有跟break语句，则继续往下执行。

  关于该题解析，请看以下注解：

  #include <stdio.h>
  int main() {
  	int x = 3;
  	int y = 3;
  	switch (x % 2) {  // x%2的结果为1，因此执行case1
  	case 1:
  		switch (y)   // y是3，因此会执行case3，而case3不存在，那只能执行default
  		{
  		case 0:
  			printf("first");
  		case 1:
  			printf("second");
  			break;
  		default: printf("hello"); // 打印hello，打印完之后，内部switch结束，此时外部case1结束
  		}             // 因为外部case1之后没有添加break语句，所以继续执行case2
  	case 2:             // 打印third
  		printf("third");      // 外部switch结束
  	}
  	return 0;
  }
  

  即：先在内部switch的default位置打印hello，紧接着在外部case2中打印third

  因此：选择D

7.能把函数处理结果的2个数据返回给主调函数，在下面的方法中不正确的是：（ ）

A.return 这2个数

B.形参用数组

C.形参用2个指针

D.用2个全局变量

答案解析：

A：错误，一个函数只能返回一个结果

B：正确，将形参存在数组中，修改数组中内容，可以通过数组将修改结果带出去

C：正确，形参如果用指针，最终指向的是外部的实参，在函数中对指向指向内容进行修改，改变的就是外部的实参

D：正确，全局变量不受函数的结束而结束，在函数中改变全局变量，主调函数中可以看到改变之后的结果

因此，选择A

 

8.下面代码的结果是：( )

#include <stdio.h>
int main()
{
    char str[] = "hello bit";
    printf("%d %d\n", sizeof(str), strlen(str));
	  return 0;
}

A.10 9

B.9 9

C.10 10

D.9 10

答案解析：

str字符数组使用"hello bit"初始化，最终也会将'\0'放置到数组中，因此数组中总共有10个元素

sizeof(str)：获取数组的总大小，10个元素，每个元素占1个字节，因此总共是10个字节

strlen(str): 获取字符串中有效字符的个数，不算'\0'，因此总共9个有效字符

故上述printf会分别打印：10  9

因此，选择A

9.下面代码的结果是：( )

#include <stdio.h>
int main()
{
    int arr[] = {1,2,(3,4),5};
    printf("%d\n", sizeof(arr));
    return 0;
}

A.4

B.16

C.20

D.5

答案解析：

对于int arr[] = {1,2,(3,4),5}数组，里面总共有4个元素，(3,4)为逗号表达式，取后者，因此数组中元素分别为：1,2,4,5

而sizeof(arr)求的是整个数组所占空间的大小，即：4*sizeof(int)=4*4=16

因此，选择B

10.下面代码的结果是：( )

#include <stdio.h>
int main()
{
	int a, b, c;
	a = 5;
	c = ++a;
	b = ++c, c++, ++a, a++;
	b += a++ + c;
	printf("a = %d b = %d c = %d\n:", a, b, c);
	return 0;
}

A.a = 8 b = 23 c = 8

B.a = 9 b= 23 c = 8

C.a = 9 b = 25 c = 8

D.a = 9 b = 24 c = 8

答案解析：

++运算符：分为前置++和后置++，

前置++：先加1，后使用，即先使用变量中内容，然后给结果加1

后置++：先使用变量中内容，整个表达式结束时，给变量加1

逗号表达式，取最后一个表达式的值。

#include <stdio.h>
int main()
{
	int a, b, c;
	a = 5;
	c = ++a;// ++a：加给a+1，结果为6，用加完之后的结果给c赋值，因此：a = 6  c = 6
	b = ++c, c++, ++a, a++;
   // 逗号表达式的优先级，最低，这里先算b=++c, b得到的是++c后的结果，b是7
   // b=++c 和后边的构成逗号表达式，依次从左向右计算的。
   // 表达式结束时，c++和，++a,a++会给a+2，给c加1，此时c：8，a：8，b:7
	b += a++ + c; // a先和c加，结果为16，在加上b的值7，比的结果为23，最后给a加1，a的值为9
	printf("a = %d b = %d c = %d\n:", a, b, c); // a:9, b:23, c:8
	return 0;
}

因此：选择B

11.下面代码的结果是：

#include <stdio.h>
int i;
int main()
{
    i--;
    if (i > sizeof(i))
    {
        printf(">\n");
    }
    else
    {
        printf("<\n");
    }
    return 0; 
}

A.>

B.<

C.不输出

D.程序有问题

答案解析：

C语言中，0为假，非0即为真。

全局变量，没有给初始值时，编译其会默认将其初始化为0。

i的初始值为0，i--结果-1，i为整形，sizeof(i)求i类型大小是4，按照此分析来看，结果应该选择B，但是sizeof的返回值类型实际为无符号整形，因此编译器会自动将左侧i自动转换为无符号整形的数据，-1对应的无符号整形是一个非常大的数字，超过4或者8，故实际应该选择A

这道题其实很隐蔽，真是虾仁猪心！！！

因此：选择A

12.下面代码的结果是：（ ）

#include <stdio.h>
int main()
{
    int i = 1;
    int ret = (++i)+(++i)+(++i);
    printf("ret = %d\n", ret);
	return 0;
}

A.10

B.12

C.9

D.程序错误

答案解析：

表达式(++i)+(++i)+(++i)，只有操作符的优先级和结合性，没法确定唯一计算路径

所以这个表达式可能因为计算顺序的差异导致结果是不一致的，所以表达式是错误的表达式。

可以在VS和Linux gcc测试，结果可能有差异。

因此：选择D

13.在小端机器中，下面代码输出的结果是：（ ）

#include <stdio.h>
int main()
{
    int a = 0x11223344;
    char *pc = (char*)&a;
    *pc = 0;
    printf("%x\n", a);
    return 0;
}

A.00223344

B.0

C.11223300

D.112233

答案解析：

假设，a变量的地址为0x64，则a变量在内存中的模型为：
0x64| 44 |
0x65| 33 |
0x66| 22 |
0x67| 11 |

char*类型的指针变量pc指向只能指向字符类型的空间，如果是非char类型的空间，必须要将该空间的地址强转为char*类型。
char *pc = (char*)&a; pc实际指向的是整形变量a的空间，即pc的内容为0x64，即44，
*pc=0，即将44位置中内容改为0，修改完成之后，a中内容为：0x11223300

因此：选择C

14.下面代码的结果是：（ ）

#include <stdio.h>
int main()
{
  int arr[] = {1,2,3,4,5};
  short *p = (short*)arr;
  int i = 0;
  for(i=0; i<4; i++)
  {
    *(p+i) = 0;
  }
   
  for(i=0; i<5; i++)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}

A.1 2 3 4 5

B.0 0 3 4 5

C.0 0 0 0 5

D.1 0 0 0 0

答案解析：

arr数组在内存中的存储格式为：
0x00ECFBF4:  01 00 00 00
0x00ECFBF8:  02 00 00 00
0x00ECFBFC:  03 00 00 00
0x00ECFC00:  04 00 00 00
0x00ECFC04:  05 00 00 00
指针p的类型为short*类型的，因此p每次只能所有两个字节，for循环对数组中内容进行修改时，一次访问的是：
arr[0]的低两个字节，arr[0]的高两个字节，arr[1]的低两个字节，arr[1]的高两个字节，故改变之后，数组中内容如下：
0x00ECFBF4:  00 00 00 00
0x00ECFBF8:  00 00 00 00
0x00ECFBFC:  03 00 00 00
0x00ECFC00:  04 00 00 00
0x00ECFC04:  05 00 00 00
故最后打印：0   0   3   4   5
因此：选择B

15. 下面哪个是指针数组：（ ）

A. int* arr[10];

B.int * arr[];

C.int **arr;

D.int (*arr)[10];

答案解析：

指针数组是一个数组，该数组的每个元素是一个指针

A：正确，定义了一个数组，该数组中有10个元素，每个元素都是int*的指针类型

B：错误，编译失败，定义数组时，要给出空间的大小，如果没有给时，必须要给出初始化结果

C：错误，定义了一个二级指针

D：错误，*和arr先结合，说明arr不是数组。实际上arr是一个指针，一个指向数组的指针

因此：选择A

16.关于Debug和Release的区别说法错误的是：（ ）

A.Debug被称为调试版本，程序调试找bug的版本

B.Release被称为发布版本，测试人员测试的就是Release版本

C.Debug版本包含调试信息，不做优化。

D.Release版本也可以调试，只是往往会优化，程序大小和运行速度上效果最优

答案解析：

A：正确，Debug为调试版本，一般在开发完成后发布工程前，调试代码都是在Debug模式下进行

B：正确，Release版本最终是要发送给用户的，发给用户的版本必须要没有问题，测试人员就是最后一个把关的

C：正确，Debug版本是调试版本，编译器编译时会增加一些调试信息，编译器基本不会对其进行优化

D：错误，Release版本是不能调试的，一般都是在Debug版本下调试的，Release版本一般编译器会进行大量的优化，删除无用的代码，指令的次序调整等，让其速度更快

因此：选择D

 

17.下面代码的结果是（ ）

int main()
{
  char a[1000] = {0};
  int i=0;
  for(i=0; i<1000; i++)
  {
    a[i] = -1-i;
  }
  printf("%d",strlen(a));
  return 0;
}

A.1000

B.999

C.255

D.256

a是字符型数组，strlen找的是第一次出现尾零（即值为0）的位置。考虑到a[i]其实是字符型，如果要为0，则需要-1-i的低八位要是全0，也就是问题简化成了“寻找当-1-i的结果第一次出现低八位全部为0的情况时，i的值”（因为字符数组下标为i时第一次出现了尾零，则字符串长度就是i）。只看低八位的话，此时-1相当于255，所以i==255的时候，-1-i（255-255）的低八位全部都是0，也就是当i为255的时候，a[i]第一次为0，所以a[i]的长度就是255了，故选C。 

18.程序的执行结果为（ ）

int main()
{
  unsigned char a = 200;
  unsigned char b = 100;
  unsigned char c = 0;
  c = a + b;
  printf(“%d %d”, a+b,c);
  return 0;
}

A.300 300

B.44 44

C.300 44

D.44 300

说明：printf在传入参数的时候如果是整形会默认传入四字节，所以a+b的结果是用一个四字节的整数接收的，不会越界。而c已经在c = a + b这一步中丢弃了最高位的1，所以只能是300-256得到的44了。

※由于printf是可变参数的函数，所以后面参数的类型是未知的，所以甭管你传入的是什么类型，printf只会根据类型的不同将用两种不同的长度存储。其中8字节的只有long long、float和double（注意float会处理成double再传入），其他类型都是4字节。所以虽然a + b的类型是char，实际接收时还是用一个四字节整数接收的。另外，读取时，%lld、%llx等整型方式和%f、%lf等浮点型方式读8字节，其他读4字节。选C

19.下面哪个代码是错误的？( )

下面哪个代码是错误的？( )

#include <stdio.h>
int main()
{
  int *p = NULL;
  int arr[10] = {0};
  return 0;
}

A.p = arr;

B.int (*ptr)[10] = &arr;

C.p = &arr[0];

D.p = &arr;

 就数据类型来看，A左右两边都是int *，B左右两边都是 int (*)[10]，C左右两边都是int *，D左边是 int *，右边是 int (*)[10]，故选D。

 20.下面关于"指针"的描述不正确的是：（ ）

A.当使用free释放掉一个指针内容后,指针变量的值被置为NULL

B.32位系统下任何类型指针的长度都是4个字节

C.指针的数据类型声明的是指针实际指向内容的数据类型

D.野指针是指向未分配或者已经释放的内存地址

A选项目前只需要了解free不会更改指针的指向。

B选项强调了32位系统，所以没问题。

CD选项是定义本身。

所以排除法也可以确定是A。

21. 如何定义一个int类型的指针数组，数组元素个数为10个：( )

A.int a[10]

B.int (*a)[10]

C.int *a[10];

D.int (*a[10])(int);

题目要int的指针数组，A为int数组，B为int数组的指针，C为int的指针数组，D为int(*)(int)函数指针的数组，故选C 

22.下面代码关于数组名描述不正确的是（ ）

int main()
{
  int arr[10] = {0};
  return 0;
}

A.数组名arr和&arr是一样的

B.sizeof(arr)，arr表示整个数组

C.&arr，arr表示整个数组

D.除了sizeof(arr)和&arr中的数组名，其他地方出现的数组名arr，都是数组首元素的地址。

A选项错误明显。arr的类型是int [10]，而&arr的类型是int (*)[10]，根本不是一个类型，不可能是一样的。而在 sizeof(arr)和&arr中，arr都是看成整体的，而一般它代表一个数组的首地址。 选A

23.定义一个函数指针，指向的函数有两个int形参并且返回一个函数指针，返回的指针指向一个有一个int形参且返回int的函数？下面哪个是正确的？（ ）

A.int (*(*F)(int, int))(int)

B.int (*F)(int, int)

C.int (*(*F)(int, int))

D.*(*F)(int, int)(int)

D类型不完整先排除，然后看返回值，B的返回值是int，C的返回值是int *，故选A。判断返回值类型只需要删掉函数名/函数指针和参数列表再看就行了。int (*(*F)(int, int))(int)删掉(*F)(int, int)后剩下int (*)(int)，符合题意,选A。

24.下面哪个是函数指针？( )

A.int* fun(int a, int b);

B.int(*)fun(int a, int b);

C.int (*fun)(int a, int b);

D.(int *)fun(int a, int n);

 

ABD没有区别，加的括号没有影响任何优先级，都是返回值为int *的函数，故选C。 

二、编程题

持续更新中，未完待续..

老铁们觉得对你有帮助还请点赞转发评论，你的支持是对我最大的鼓励。