函数
第 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: 错误，有了优先级和结核性，表达式也有可能有不同的计算机路径，导致计算结果的差异。
