C语言易错知识点总结2

函数 

第 1 题（单选题）

题目名称：

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

题目内容：

A .return 这二个数

B .形参用数组

C .形参用二个指针

D .用二个全局变量

答案解析：

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

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

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

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

因此，选择A

第 2 题（单选题）

题目名称：

关于函数调用说法不正确的是：（ ）

题目内容：

A .函数可以传值调用，传值调用的时候形参是实参的一份临时拷贝

B .函数可以传址调用，传址调用的时候，可以通过形参操作实参

C .函数可以嵌套定义，但是不能嵌套调用

D .函数可以嵌套调用，但是不能嵌套定义

答案解析： 

A：正确，形参按照值的方式传递，将来形参就是实参的一份临时拷贝，修改形参不会影响外部的实参

B：正确，形参按照指针方式传递，将来形参就是实参地址的一份拷贝，形参指向的是实参，修改形参指针指向的内容，  就是在操作实参

C：错误，C语言中，函数不能嵌套定义

D：正确，函数可以嵌套调用，即：A()中调用B()，B()中调用A()，但是要控制好，否则就成为无限递归

因此，选择C

第 3 题（单选题）

题目名称：

在函数调用时，以下说法正确的是：（ ）

题目内容：

A .函数调用后必须带回返回值

B .实际参数和形式参数可以同名

C .函数间的数据传递不可以使用全局变量

D .主调函数和被调函数总是在同一个文件里

答案解析： 

A：错误，函数可以没有返回值，如果没有返回值也就不需要待会任何结果

B：正确，形参和实参在不同的函数中，即不同的作用域，因此形参和实参可以同名

C：错误，可以使用全局变量传参

D：错误，不一定，函数的定义可以放在任意的文件中，使用时只需要包含头文件即可

因此，选择B

第 4 题（单选题）

题目名称：

关于函数的声明和定义说法正确的是：（ ）

题目内容：

A .函数的定义必须放在函数的使用之前

B .函数必须保证先声明后使用

C .函数定义在使用之后，也可以不声明

D .函数的声明就是说明函数是怎么实现的

答案解析： 

A：错误，函数的定义可以放在任意位置，函数的声明必须放在函数的使用之前

B：正确

C：错误，函数定义在使用之后，使用之前没有声明时，编译器编译时识别不了该函数

D：错误，函数的声明只是告诉编译器函数返回值类型、函数名字以及函数所需要的参数，函数定义才是说明函数是怎么  实现的

因此，选择B

第 5 题（单选题）

题目名称：

关于实参和形参描述错误的是：（ ）

题目内容：

A .形参是实参的一份临时拷贝

B .形参是在函数调用的时候才实例化，才开辟内存空间

C .改变形参就是改变实参

D .函数调用如果采用传值调用，改变形参不影响实参

 答案解析： 

A：正确，传参时不论是按照值还是指针方式传递，形参拿到的都是实参的一份拷贝

B：正确，函数没有调用时，新参没有空间

C：错误，如果是按照值的方式传递，形参和实参各自有各自的空间，改变形参不能改变外部的实参

D：正确，因为形参和实参是两个不同的变量

因此，选择C

第 6 题（单选题）

题目名称：

函数调用exec((vl，v2)，(v3，v4)，v5，v6);中，实参的个数是：（ ）

题目内容：

A .3

B .4

C .5

D .6

答案解析： 

exec((vl，v2)，(v3，v4)，v5，v6) 总共有四个参数

 (v1, v2)属于第一个实参，逗号表达式，真实的参数时v2

 (v3，v4)属于第二个实参，逗号表达式，真实的参数是v4

 v5属于第三个实参

 v6属于第四个实参

 因此选择：B 

第 7 题（单选题）

题目名称：

以下关于函数设计不正确的说法是：（ ）

题目内容：

A .函数设计应该追求高内聚低耦合

B .要尽可能多的使用全局变量

C .函数参数不易过多

D .设计函数时，尽量做到谁申请的资源就由谁来释放

答案解析： 

A：正确，高内聚低耦合即：函数体内部实现修改了，尽量不要对外部产生影响，否则：代码不方便维护

B：错误，全局变量每个方法都可以访问，很难保证数据的正确性和安全性

C：正确，参数越少越好，否则用户在使用时体验不是很好，还得必须将所有参数完全搞明白才可以使用

D：正确，谁申请的谁维护谁释放，否则如果交给外部使用者释放，外部使用者可能不知道或者忘记，就会造成资源泄漏

因此，选择B

第 8 题（单选题）

题目名称：

关于C语言函数描述正确的是：（ ）

题目内容：

A .函数必须有参数和返回值

B .函数的实参只能是变量

C .库函数的使用必须要包含对应的头文件

D .有了库函数就不需要自定函数了

答案解析： 

A：错误，可以没有参数和返回值类型，根据需要给出

B：错误，函数的实参可能是变量，也可能是常量，也可能是宏，也可能是指针等等

C：正确，在使用库函数时，必须要包含该库函数所在的头文件，否则编译器将不能识别

D：错误，库函数是语言设计者为了让用户能够更好的使用，而给出的，但并不能解决用户的所有问题，因此其他问题还

  需要用户自己写方法解决

因此：选择C

第 9 题（单选题）

题目名称：

以下叙述中不正确的是：（ ）

题目内容：

A .在不同的函数中可以使用相同名字的变量

B .函数中的形式参数是在栈中保存

C .在一个函数内定义的变量只在本函数范围内有效

D .在一个函数内复合语句中定义的变量在本函数范围内有效（复合语句指函数中的成对括号构成的代码）

答案解析： 

A：正确 不同的函数属于不同的作用域，因此不同的函数中定义相同名字的变量不会冲突

B：正确 在C语言中，函数的形参一般都是通过参数压栈的方式传递的

C：正确 在函数内定义的变量，称为局部变量，局部变量只能在其定义的函数中使用

D：错误 复合语句中定义的变量只能在复合语句中使用

因此：选择D 

第 10 题（单选题）

题目名称：

C语言规定，在一个源程序中，main函数的位置（ ）

题目内容：

A .必须在最开始

B .必须在库函数的后面

C .可以任意

D .必须在最后

答案解析： 

main函数的位置可以在任意位置，但是如果在主函数之中调用了哪些函数，必须在main函数前对其所调用函数进行生命或包含其被调用函数的头文件。

因此：选择C

函数递归

第 1 题（单选题）

题目名称：

关于递归的描述错误的是：（ ）

题目内容：

A .存在限制条件，当满足这个限制条件的时候，递归便不再继续

B .每次递归调用之后越来越接近这个限制条件

C .递归可以无限递归下去

D .递归层次太深，会出现栈溢出现象

答案解析：

递归的两个条件：

 1. 将问题转化为其子问题，子问题要与原问题具有相同的解法

 2. 递归的出口

A：正确，限制条件即递归的出口，如果限制条件满足，递归程序就可以退出了

B：正确，因为每次递归，都是将原问题进一步缩小，缩小到限制条件时，就可以往回返，直到第一次递归调用

  比如：递归求和

 int Sum(int N)
   {
     if(N == 1)
       return 1;
       
     return Sum(N-1)+N;
   }

   假设：求Sum(4)的递归调用过程

      Sum(4)<----
        |       |
        |       |
      Sum(3)<----
        |       |
        |       |
      Sum(2)<----
        |       |
        |       |
      Sum(1)-----

 C：错误，递归不能无限递归下去，否则会造成死循环和栈溢出

 D：正确，因为每次递归，相当于都是一次新的函数调用，而每次函数调用系统必须给该函数划分栈帧空间，内部的递   归函数没有退出，上层的递归就不能退出，栈帧就会累积许多块，如果累积超过栈的总大小，就会栈溢出。

 因此：选择C

第 2 题（单选题）

题目名称：

根据下面递归函数：调用函数Fun(2)，返回值是多少（ ）

int Fun(int n)      
{ 
  if(n==5)   
    return 2;     
  else     
    return 2*Fun(n+1);      
}

题目内容：

A .2

B .4

C .8

D .16

答案解析：

Fun(2)--->返回16
 return 2*Fun(3)  2*8=16
      |__Fun(3):8
         return 2*Fun(4)  2*4=8
              |__Fun(4):4
                 return 2*Fun(5) 2*2=4
                      |__Fun(5):2  
                         return 2

因此，选择D

数组的定义和初始化

第 1 题（单选题）

题目名称：

关于一维数组初始化，下面哪个定义是错误的？（ ）

题目内容：

A .int arr[10] = {1,2,3,4,5,6};

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

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

D .int arr[10] = {0};

答案解析： 

A：正确，10个int的一段连续空间，前6个位置被初始化为1,2,3，4,5,6，其他位置为0

B：正确，数组中有6个空间，并被初始化为1,2,3,4,5,6

C：错误，数组的初始化不能使用()，只能使用{}

D：正确，10个int类型的一段连续空间，每个位置都被初始化为0

因此，选择C

第 2 题（单选题）

题目名称：

定义了一维 int 型数组 a[10] 后，下面错误的引用是：（ ）

题目内容：

A .a[0] = 1;

B .a[0] = 5*2;

C .a[10] = 2;

D .a[1] = a[2] * a[0];

答案解析： 

数组是相同类型的一段连续的空间，下标是从0开始的，比如：int array[N]

下标的范围为[0,N),其中N位置不能存储有效元素

A：正确，将0号位置设置为1

B：正确，将0号位置设置为10

C：错误，越界

D：正确，1号位置初始化为a[2]*a[0]之后的结果

因此，选择C

第 3 题（单选题）

题目名称：

下面代码的结果是：( )

#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

第 4 题（单选题）

题目名称：

关于一维数组描述不正确的是：( )

题目内容：

A .数组的下标是从0开始的

B .数组在内存中是连续存放的

C .数组名表示首元素的地址

D .随着数组下标的由小到大，地址由高到低

答案解析： 

A：正确，C语言规定，数组的下标是从0开始的

B：正确，数组的空间是一段连续的内存空间

C：正确，数组名既可以表示数组的地址，也可以表示数组首元素的地址，两个在数值上是一样的，但是含义不一样。

  注意：数组名只有在sizeof和&后才代表整个数组，其它都表示首元素的地址

D：错误，这个要是系统而定，一般都是下标由小到大，地址由低到高

因此，选择D

第 5 题（单选题）

题目名称：

以下能对二维数组a进行正确初始化的语句是：（ ）

题目内容：

A .int a[2][]={{0,1,2},{3,4,5}};

B .int a[][3]={{0,1,2},{3,4,5}};

C .int a[2][4]={{0,1,2},{3,4},{5}};

D .int a[][3]={{0,,2},{},{3,4,5}};

答案解析： 

对于二维数组int array[M][N], 说明如下：

 1. M和N都必须为常数，

 2. M代表数组有M行，N代表每行中有N个元素

 3. 其中M可以省略，省略后必须给出初始化表达式，编译器从初始化结果中推断数组有多少行

 4. N一定不能省略，因为N省略了就不能确定一行有多少个元素，也不能确定数组有多少行

A：错误，参数上述说明

B：正确，参考上述说明

C：错误，数组有两行，但是初始化给了三行

D：错误，初始化不允许{0,,2}该种情况存在

因此，选择B

第 6 题（单选题）

题目名称：

若定义int a[2][3]={1,2,3,4,5,6};则值为4的数组元素是( )

题目内容：

A .a[0][0]

B .a[1][0]

C .a[1][1]

D .a[2][1]

答案解析： 

int a[2][3]表示2行3列的二维数组，根据其初始化知：

第0行即a[0]存储3个元素： 1,2,3

第1行即a[1]存储3个元素： 4,5,6

因此值为4的元素在第1行第0列

因此，选择B

第 7 题（单选题）

题目名称：

给出以下定义：

char acX[] = "abcdefg";
char acY[] = { 'a','b','c','d','e','f','g'};

以下说法正确的是( )

题目内容：

A .数组acX和数组acY等价

B .数组acX和数组acY的长度相同

C .sizeof(acX)>sizeof (acY)

D .strlen (acX)>strlen (acY)

答案解析： 

acX和acY都是字符数组，但是初始化表达式不同，acX和acY的区别如下：

acX：数组中总共有8个元素，分别是：'a','b','c','d','e','f','g','\0'

acY：数组中总共有7个元素，分别是：'a','b','c','d','e','f','g'

sizeof求的是有效元素个数

strlen求的是字符串长度，从首元素开始计算，遇见‘\0’停止，由于acY数组没有'\0‘，所以strlen(acY)的结果是个随机值

因此，选择C

第 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

第 1 题（单选题）

题目名称：

下面哪个是位操作符：（ ）

题目内容：

A .&

B .&&

C .||

D .!

答案解析： 

A. & 是按位与操作符，正确

B. && 是逻辑与，不是按位与，错误

C. || 是逻辑或，错误

D. ! 是逻辑反操作符，错误

第 2 题（单选题）

题目名称：

下面代码的结果是：( )

#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

算术转换

第 1 题（单选题）

题目名称：

下面代码的结果是：（ ）

#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测试，结果可能有差异。

 

第 2 题（单选题）

题目名称：

下面代码的结果是：

#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

第 3 题（单选题）

题目名称：

关于表达式求值说法不正确的是：（ ）

题目内容：

A .表达式求值先看是否存在整形提升或算术转换，再进行计算

B .表达式真正计算的时候先看相邻操作符的优先级决定先算谁

C .相邻操作符的优先级相同的情况下，看操作符的结合性决定计算顺序

D .只要有了优先级和结合性，表达式就能求出唯一值

答案解析：

A：正确

B：正确

C：正确

D: 错误，有了优先级和结核性，表达式也有可能有不同的计算机路径，导致计算结果的差异。