C语言习题集（100题）+

C语⾔习题集（100题）+
1. i=2;printf("%d",i++);打印出来的数字为？
答案：2
解：i++和++i均为⾃增表达式，执⾏完后，i都会加1，均会有i+=1，也就是
i=2+1=3的效果。

不过，两个表达式的值不同。

i++表达式的值为⾃增1之前i的值。

这⾥也就是2。

++i为只增1之后的i的值，也就是3。

因此，i=2;printf("%d",i++);打印出来的数字为2；
i=2;printf("%d",++i);打印出来的数字为3。

2. unsigned char i=0;i--;i为？
答案：255
unsigned char的为1个字节，数据范围从0~255。

i=0已经位于数据范围的下边界，如果再-1，会发⽣负溢出，溢出⾄255。

如果i=255，再加1，则会发⽣正溢出，溢出⾄0。

类似的情况参考下表
3. signed char i=0;i--;此时i为？
答案:-1
解：参考表1
signed char数据范围从-128~127。

当i=0，i⾃减1，不会发⽣溢出。

因此，i=0-1=-1
4. int i;for(i=0;i<100;i--);循环次数为？100
5. int i;for(i=0;i<100;i++);循环结束后，i=？100
解：参考表1
int的范围为-21亿~+21亿
因此，i在0~100的范围内的⾃增1操作，不会发⽣溢出。

循环次数计算考虑i的值的变化，i从0变到99，都满⾜i<100循环执⾏条件。

当i=99+1的时候，条件被打破，循环推出。

因此，循环推出后i=100
如果没有溢出，则通过以下公式计算
for(i=start;i
循环次数为（end-1）-start+1=end-start（使⽤等⽐数列公式：项数=(a n-a0)/delta+1 循环结束后i=end
如果没有溢出，则通过以下公式计算
for(i=start;i<=end;i++)
循环次数为end-start+1
循环结束后i=end+1
6. unsigned short i;for(i=0;i<40000;i++);循环次数为？A.40000 B.⽆穷⼤
答案：选A
参考表1
unsigned short范围为0~65535，
该循环不会溢出。

等差数列公式
an=a0+(n-1)*delta
n为项数，也就是循环次数
an=39999,a0=0
delta=1
循环次数=(an-a0)/detla+1=(39999-0)/1+1=40000
7. signed short i;for(i=0;i<40000;i++);循环次数为？ A.40000 B.⽆穷⼤
答案为B
参见表1
signed short数据范围从-32768~32767
循环会溢出
当i=32767的时候，i++使得i溢出到-32768，因此，i永远不可能达到40000。

该循环为死循环。

8. float i;for(i=0.0F;i<.0F;i+=1.0F);循环次数为A. B.⽆穷⼤，答案A
9.float i;for(i=0.0F;i<.0F;i+=1.0F);循环次数为A. B.⽆穷⼤，答案B
float有效位数为7，当i=的时候，执⾏i++
+ 1
----------------------------
1加在第6位有效数字上，在7位以内，则不会出现精度不够的情况。

如果是i=.0F，同样执⾏i+=1.0F
1是加到第9位有效数字上的，会出现精度不够的情况。

具体表现为x+deltax==x
也就是i+=1.0F将不再使i能够继续增⼤
此时，i永远不会达到.0F，循环成为死循环。

10. printf函数中，%lf对应哪种数据类型?
%lf double
%f float
%d int
%ld long
%c char
%s char s[]
%x 整数以⼗六进制显⽰（⼩写的abcdef）
%X 整数以⼗六进制显⽰（⼤写的ABCDEF）
%u unsigned int
%o 整数以⼋进制显⽰
11. a的ASCII码是? 97
12. A的ASCII码是？65
13. 0的ASCII码是? 48
14. \n的ASCII码是？10
15. char s[]="123";strlen(s)的值为？3
strlen是string.h中声明的库函数，⽤于显⽰字符串中除’\0’以外的字符个数。

16. char s[]="123";sizeof(s)的值为?
sizeof是关键字，⽤于显⽰变量或数据类型的字节数。

int a; sizeof(a)为4
sizeof(int)为4
char s[]="123";sizeof(s)的值为数组元素个数*每个元素的字节数=4*1=4
这⾥数组元素个数应包含末尾的’\0’
17. 提前退出循环的关键字是？break;
int i;
for(i=0;i<10;i++)
{
if(i==5)
break;
printf(“%d,”,i);
}
屏幕输出为0,1,2,3,4,
18. 提前结束本次循环的关键字是？continue;
int i;
for(i=0;i<10;i++)
{
if(i==5)
continue;
printf(“%d,”,i);
}
屏幕输出为0,1,2,3,4,6,7,8,9,
19. 有⼀个关键字可以构造出while循环，该关键字是？答案可以是goto，也可以是for
以下三个循环的作⽤是⼀样的，
都是在屏幕上输出0，1，2，3，4，5，6，7，8，9，int i;
i=0;
while（i<10）
{
printf(“%d,”,i);
i++;
}
int i;
i=0;
LOOP:
if(i<10)
{
printf(“%d,”,i);
i++;
goto LOOP;
}
int i;
for(i=0;i<10;i++)
{
printf(“%d,”,i);
}
20. 请⽤宏定义给unsigned int⼀个别名UINT
#define UINT unsigned int
21. 请⽤typedef给unsigned int⼀个别名uint
typedef unsigned int UINT;
注意typedef后⾯有；
⽽且两者在别名和原名的顺序上是相反的。

22. 如果要⽤到printf，需要include哪个头⽂件？
23. 如果需要⽤到sqrt，需要include哪个头⽂件？
printf, scanf, getchar, putchar 使⽤之前都得#include sqrt, sin ,cos 使⽤之前都得#include
strlen使⽤之前都得#include
24. 0x22转化为⼗进制为___ 34
0x22=2*161+2*160=34
25. 22转化为⼗六进制
22/16=1 22%16=6
1/16=0 1%16=1
22转化为16进制为0x16
222转化为16进制
222/16=13 222%16=14
13/16=0 13%16=13
14转化为⼗六进制为E
13转化为⼗六进制为D
222转化为16进制为0xDE
26. 22转化为⼆进制数为______（前⾯的0不要省略，总共写出8位数字）思路：先转化为16进制，再由16进制转化为2进制。

22转化为16进制为0x16，0x16转化为⼆进制为
0x22转化为⼆进制为_____（前⾯的0不要省略，总共写出8位数字）
0x22转化为⼆进制为
对于⼗六进制到⼆进制的转化
可以现先在草稿纸上写出如下表格，然后查表
27. 0x22转化为⼆进制为____（前⾯的0不要省略，总共写出8位数字）直接查表
0x22=
28. int的上限为多少亿？（写出数字即可，不要带单位）
int范围 -21亿~21亿，见表1
29. 编译程序程序总共有四部，第⼀步是？A.预处理 B.链接
编译程序程序总共有四部：预处理-》编译-》汇编-》链接
30. 预处理指令前通常有什么符号？#
#define
#include
#ifdef
#endif
31.void是否为合法的变量名？（填T或F）F
32. _123是否是合法的变量名？（填T或F）T
合法变量名以下划线_和字母开头，中间可以有数字。

不能⽤关键字。

void为关键字，不能作为合法变量名。

但是Void可以，因为C语⾔区分⼤⼩写33. char a[]该数组的定义是否正确？（填T或F）T
sizeof（a）=*sizeof(a[0])=<1024*1024=1M Bytes
因此在运⾏的时候，不会发⽣栈溢出错误。

34. int a[]该数组的定义是否正确？（填T或F）F
sizeof（a）=*sizeof(a[0])=*4>1024*1024=1M Bytes
编译的时候不会报错，运⾏的时候，会报栈溢出错误。

提⽰，定义函数中的数组有字节限制，最⼤不能超过1M Bytes
35. int a[3];请问sizeof(a)=?
sizeof(a)=sizeof(a[0])*3=4*3=12
36. int a[3][4];请问sizeof(a)=?
sizeof(a)=sizeof(a[0][0])*(3*4)=4*12=48
37. int a[3];请问最后⼀个元素为?（填写a[x]）
int a[N];
a数组中最后⼀个元素为a[N-1]
第⼀个元素为a[0]
38. int a[3][4];请问最后⼀个元素为?（填写a[x][y]）
int a[M][N];
a的最后⼀个元素为a[M-1][N-1]
a的第⼀个元素为a[0][0]
39.定义在函数体外的变量称之为全局变量。

（填写T或F）T
40. 局部变量只能在定义该变量的函数内使⽤。

（填写是或否）T
#include
int i=10;//i为全局变量
void print()
{
printf(“i=%d”,i);
//正确，全局变量可以被定义在它下⾯的所有函数引⽤，这⾥包括print和main//都可以使⽤i printf(“j=%d”,j);
//正确，局部变量只能在定义它的函数内使⽤，这⾥j只能在main中使⽤
}
int main()
{
int j=5;//j为定义在main中的局部变量，只能在main中使⽤
printf(“i=%d”,i);
//正确，全局变量可以被定义在它下⾯的所有函数引⽤，这⾥包括print和main//都可以使⽤i printf(“j=%d”,j);
//正确，局部变量只能在定义它的函数内使⽤
}
41. char c='\123';printf("%c\n",c);打印输出为_____
‘\123’这是⼋进制，先转化成10进制
1238=1*82+2*81+3*80=64+16+3=83
因65为A的ASCII码，可以推出83为S
42. int b=3; int a=(b<2?0:1); printf("%d\n",a);
：为三⽬运算符
表达式1？表达式2：表达式3
如果表达式1为真，这返回表达式2的值，否者返回表达式3的值。

b<2的值为假，所以需要返回表达式3也就是1
因此a=1
43. int b=3; int a=(b=2?0:1); printf("%d\n",a);
：为三⽬运算符
表达式1？表达式2：表达式3
因为=的优先级，⼩于三⽬运算符，所以先看?前⾯的常量表达式2，
表达式的值就是2
2不等于0，？前⾯的表达式为真。

因此a=表达式2的值=0
44. unsigned char i=0xFF; i&=~(unsigned char)(1<<5);求i（答案以0x开头）
整数常量在C语⾔中，默认是int型的，因此1在内存中总共占⽤4字节，32位0000 0000 0000 0000 0000 0000 0000 0001
1<<5表⽰1左移5位，后⾯补0
0000 0000 0000 0000 0000 0000 0010 0000
（unsigned char）（1<<5）将32位转化为8位
0010 0000
~(（unsigned char）（1<<5）)是按位取反操作
1101 1111
i+=1 i=i+1
i&=~(（unsigned char）（1<<5）)也就是i&=1101 1111，
等价于i=i&=1111 1111 & 1101 1111=1101 1111=0xDF
&为按位与操作，有0为0，全1才为1
45. unsigned char i=0x11;i|=(unsigned char)(1<<5);求i（答案以0x开头）
(unsigned char)(1<<5)= 0010 00002
|为按位或操作，有1为1，全0才为0
i=0x11=
i|=(unsigned char)(1<<5)也就是i|=0010 00002
等价于i=i|0010 00002=|0010 00002=0011 =0x31
四位⼆进制数可以转化为⼀位⼗六进制数，从低位（右边）向左数位数，四位⼀组，不⾜四位的可以补0.
46. 写出与printf相对应的输⼊函数的名称为scanf
printf⽤于格式输出，scanf⽤于格式输⼊
47. 写出读取⼀个字符的输⼊函数的名称
putchar⽤于向屏幕输出⼀个字符
与putchar相对应的输⼊函数为getchar，getchar⽤于从键盘输⼊读取⼀个字符
48. int i=1,j=2;
if (i==1||j++)i++;请问j=？
if后的i++时候执⾏取决于表达式i==1||j++是否为真
因为||为逻辑或操作，有真为真，全假才为假
因此，对于表达式1||表达式2，如果表达式1为真，则⽆论表达式2的取值，整个表达式都为真。

因此，计算机在这种情况下，会跳过表达式2的计算。

i==1成⽴，因此i==1||j++必定为真，因此计算机跳过j++的计算，直接计算if后的语句
i++。

因此，j++不会被执⾏。

j=2
49. int i=1,j=2;
if (i==1&&j++)i++;请问j=？
&&为逻辑与操作，有假为假，全真才为真
对于表达式1&&表达式2，如果表达式1为假，则⽆论表达式2的取值如何，整个表达式都为假。

因此，这种情况下，计算机会
跳过表达式2。

i==1成⽴，因此系统将计算表达式2也就是j++的值，j++将被执⾏，j=3
50． int i=0,j=2;if (i==1&&j++)i++;请问j=？
i==1不成⽴，因此系统跳过计算表达式2，j++将不被执⾏，j=2
51．#define MAX(a,b) ((a)>(b)?(a):(b)),给a，b加括号是为了避免_____问题(三个字)优先级
如果不使⽤⼩括号，#define MAX(a,b) a>b?a:b
int a=1,b=2,c=3;
int d;
d=MAX(MAX(a,b),c);//求a,b,c三个数的最⼤值
等价于d=MAX(a,b)>c?MAX(a,b):c=a>b?a:b>c?a>b?a:b:c;
很可能会出现优先级问题。

52. int n=5; int a[n];该数组定义是否正确？（T或F）F
数组定义时候，[]中应为整形常量表达式。

53. 数组名右边的⽅括号中必须为常量表达式？（T或F）F
int a[5]={1,2,3,4,5};
printf(“%d\n”,a[4]);//这⾥的4是常量表达式
反例：
引⽤数组——整形
int i=4;
printf(“%d\n”,a[i]);//这⾥i是变量
54. float i;for(i=.0F;i<.0F;i+=1.0F);是⼀个死循环，如要改错，可修改i为____型（英⽂）double
因为double精度为15，所以，可避免精度不够的情况。

（见题8和9，表2）
55. #define DIM(a) sizeof(a)/sizeof(a[0]),该宏定义⽤于求数组的___ A. 元素个数 B.数组字节数
sizeof(a)为整个数组所有元素的字节数之和，sizeof(a[0])为第⼀个元素的字节数，由于对于⼀个数组，其中每⼀元素的类型和字节数都相等，因此，sizeof（a[0]）⼜表⽰数组a中每个元素的字节数。

DIM(a) =sizeof(a)/sizeof(a[0])=所有元素的总字节数/单个元素字节数=元素个数
56. switch-case语句中，每个case通常都搭配关键字_______
break
57.所有的if else语句都可以⽤switch-case语句表⽰？（T或F）
以下switch case语句将1，2，3，分别映射成5，7，12
int x=1;
int y;
switch (x)
{
case 1:y=5;break;
case 2:y=7;break;
case 3:y=12;break;
}
对应的if else语句是
int x=1;
int y;
if(x==1)
y=5;
else if(x==2)
y=7;
else if(x==3)
y=12;
如果需要将（1.54,2.32）,（2.4567，3.5498）映射成1，2，则只能⽤if else实现
double x,y;
if(x>1.54&&x<2.32)
y=1;
else if(x>2. 4567&&x<3. 5498)
y=2;
switch case 适⽤于点对点映射，if else既可以实线点对点映射，也可以将某区间映射到点。

58. 最⼤的float型数的数量级是____ 38
查表2
59. 冒泡法⽤于____（答案为两个字）
排序
60. 编译器在编译过程中可以检查源代码的哪⼀类错误？A. 功能错误 B. 语法错误编译器只能检查出语法错误，⽐如没有加分号，使⽤了没有定义的变量名等等。

61. 如果源码中有⼀个死循环，那么能否通过顺利编译？（T或F）
死循环不属于语法错误，所以编译器是检测不到的，可以顺利通过编译。

62. 升序指的是由⼩到⼤？（T或F）
升序是由⼩到⼤，降序是由⼤到⼩
63. C程序的每⾏中只能写⼀条语句？（T或F）
每⾏可以写多条语句。

⽐如以下情况是允许的
int i=0;i++; printf(“%d\n”,i);
64. 简单变量做实参时,数据传递⽅式是由实参传给形参,再由形参传回给实参？（T 或F）
简单变量是指的除去数组和指针的情况。

int add(int a,int b)//a,b为形式参数
{
这⾥隐含了a=1,b=2
相当于实参被隐含传递给了形参
return a+b;
}
int main()
{
int c;
c=add(1,2);//1，2为实际参数
}
65. stdlib.h中有个库函数可以⽤于排序,函数名为____
qsort——快速排序函数
66. 如果头⽂件是位于⼯程⽬录下，#include 后⾯⽤哪种⽅式 A. <> B. "" C. A 和B均可——B
67.如果头⽂件位于编译器安装⽬录下，#include 后⾯⽤哪种⽅式 A. <> B. "" C. A和B均可——C
<>告诉编译器，*.h⽂件位于编译器⽬录下。

“”告诉编译器，*.h⽂件位于⼯程⽬录或编译器⽬录下。

采⽤这种⽅式的时候，编译器会先搜索⼯程⽬录有没有*.h⽂件，如果没有才回去编译器⽬录下找。

因此，对于编译器⾃带的*.h⽂件，⽐如stdio.h，位于编译器⽬录下，
两种⽅式都是可以的。

不过，采⽤<>会加快编译速度，因为编译器不会去⼯程⽬录搜索*.h
⽽对于⾃⼰定义.h⽂件通常都位于⼯程⽬录下，所以只能采⽤””⽅式
68. 已知main函数中有如下语句int a;a=5;int b=6; 试问在C编译器能否编译通过？（T或F）
不能通过。

因为声明变量语句中间，不能插⼊其它语句。

可以改为
int a=5;
int b=6;
或
int a;
int b=6;
a=5;
69. 如果函数定义在main函数的后⾯,⼀般会在main前⾯添加函数的 A. 函数体 B. 函数声明
B
函数体就是指的函数定义中的花括号部分。

int add(int a,int b);//因为函数定于main函数之后，所以必须在main前⾯先声明，否则编译器会报错。

int main()
{
int c;
c=add(1,2);
}
int add(int a,int b)//这⾥为函数定义，申明和定义的区别在于是否有函数体，也就是花括号部分
{
return a+b;
}
70. 头⽂件中，通常是存放A. 函数声明 B. 函数体
A
⼤家可以⾃⼰打开编译器⽬录下的stdio.h⽂件
71. 逗号表达式的值等于最后那个逗号后的表达式的值？(T或F)
（1，2，3）的值为3
72. int a=7,b=4;
a&&b=?
&&为逻辑与，有假为假，全真才为真
a=7，不为0，就是真（作为输⼊的时候，⾮0为真，作为结果的时候，1为真）
b=4，也是真
因此真&&真=真
C语⾔中1表⽰真，0表⽰假
所以，结果为1
73. int a=7,b=4; a&b=?
&为按位与，有0为0，全1才为1
将7和4化为⼆进制，分别是0111和0100，然后按位分别与操作，结果为0100，化为⼗进制，也就是4 74. int a=7,b=4; a|b=?
|按位或操作，有1为1，全0才为0
将7和4化为⼆进制，分别是0111和0100，然后按位分别或操作，结果为0111，化为⼗进制，也就是7 75. int a=7,b=4; a||b=?
||逻辑或操作，有真为真，全假才为假
真||真=真
真就是1
结果为1
76. int a=7,b=4;a^b=?
^为按位异或，运算规则为“相同为0，不同为1”
7⼆进制形式为0111，4的⼆进制形式为0100
结果为0011，化为⼗进制为3
77. 以下运算符属于单⽬运算符的是 A. ! B. - C. > D.& （多选题）
！——逻辑⾮，单⽬
-——负号（单⽬），减号（双⽬）
>——⼤于（双⽬）
&——按位与（双⽬），取地址符（单⽬）
78. 数组名作为函数参数，则形参要在数组名后加上[]，实参则只写数组名（T或F）
T
void arrya_elem_add_one(int a[],int size)//这⾥的a为形式参数，后⾯有[],表⽰a是数组，⽽不是普通的int变量
{
int i;
for(i=0;i
a[i] = a[i] +1;
}
int main()
{
int a[3]={1,2,3};
arrya_elem_add_one(a,3);//这⾥的a为实际参数，不需要加[]
return 0;
}
79. do-while循环的循环次数必定⼤于等于1次？（T或F）
T
int i=10;
do
{
printf(“%d”,i);
i++;
}while(i<0);
屏幕输出10
do-while是先执⾏⼀次，然后才判断条件是否成⽴，如果成⽴则重新执⾏，如果不是则推出。

因此，必定会执⾏⼀次以上才会推出。

80.while循环的循环次数必定⼤于等于1次？（T或F）
F
int i=10;
while(i<0)
{
i++;
}
屏幕⽆输出
因为i=10之后，不满⾜i<0，跳过循环体。

因此不会有输出。

while是先判断再执⾏，因此如果条件⼀开始就不满⾜，就不会执⾏。

因此while循环次数可能是0次
81. C语⾔中⼀定会包含stdio.h头⽂件？（T或F）
F
如果没有⽤到printf等stdio.h中声明的函数，则不需要⽤stdio.h。