C语言面试题

发表于 | 分类于
本文设置了20道C语言面试题，快来挑战一下吧！

说明：本文题目来源于牛客网，答案分析来源个人，仅为参考

fengjingtu

题目

1、请问下面的程序最后会产生多少个进程：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
int main(　）{ 

     int i; 

     for(i = 0; i<5;i++){ 

        int pid = fork(); 

        if(pid == 0){ 

            //do something 

        } else { 

        //do something 

        } 

        }

    // do somthing,sleep

    return 0;

}

A、5 B、10 C、15 D、32


2、若有定义 int( * pt)[3]；则下列说法正确的是：

A、定义了基类型为int的三个指针变量
B、定义了基类型为int的具有三个元素的指针数组pt
C、定义了一个名为*pt、具有三个元素的整型数组
D、定义了一个名为pt的指针变量，它可以指向每行有三个整数元素的二维数组


3、（不定项选择）若 a 是 float 型变量,b 是 unsigned 型变量,以下输入语句中合法的是：

A、scanf("%6.2f%d",&a,&b);
B、scanf("%f%n",&a,&b);
C、scanf("%f%3o",&a,&b);
D、scanf("%f%f",&a,&b);


4、（不定项选择）下列程序的运行结果是PP 10003，请为横线处选择合适的程序（）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include<stdio.h>
#include<string.h>
struct STU
{
   char name[10];
   int num;
};
void f(char_____, int num)
{
   struct STU s[2]={{"SS",10001},{"PP",10002}};
   num = s[1].num;
   strcpy(name, s[1].name);
}
main()
{
   struct STU  s[2]={{"YY",10003},{"LL",10004}},*p;
   p=s;
   f(p->name, p->num);
   printf("%s %d\n", p->name, p->num);
}

A、*name B、name[] C、name D、&name

5、若 ch 为 char 型变量，k 为 int 型变量（已知字符 a 的 ASCII 十进制代码为97），则以下程序段的执行结果是（）。
1
2
3
4
5
6
7
8
void print_test()
{
    char ch='a';
    int k=12; 
    printf("%x,%o,",ch,ch,k);
    printf("k=%%d\n",k);
    return ;
}

A、因变量类型与格式描述符的类型不匹配，输出无定值

B、输出项与格式描述符个数不符，输出为零值或不定值

C、61,141,k=%d

D、61,141,k=%12

6、以下叙述中正确的是（）

A、在C语言中，逻辑真值和假值分别对应1和0
B、关系运算符两边的运算对象可以是Ｃ语言中任意合法的表达式
C、对于浮点变量x和y，表达式：x==y 是非法的，会出编译错误
D、分支结构是根据算术表达式的结果来判断流程走向的

7、unsigned int a= 0x1234; unsigned char b=(unsigned char )&a; 在32位大端模式处理器上变量b等于()?

A、0x00
B、0x12
C、0x34
D、0x1234

8、一张1024×640分辨率的图片，假定每个像素用16位色彩表示，用位图文件（bitmap）格式存储，则这张图片文件需要占用多大的存储空间

A、40KB B、640KB C、1280KB D、2560KB E、5120KB F、10240KB

9、若要以 读和写两种操作方式打开一个二进制文件，当文件不存在时返回打开失败信息，则选用的打开方式字符串为（ ）。

A、”r+” B、”ab+” C、”rb+” D、”wb+”

10、关于指针概念说法正确的是（）。

A、一个指针变量只能指向同一类型变量
B、一个变量的地址称为该变量的指针
C、只有同一类型变量的地址才能放到指向该类型变量的指针变量之中
D、指针变量可以由整数赋,不能用浮点赋

11、以下#pragma预处理命令哪个是改变编译器的对齐方式（）?

A、#pragma comment
B、#pragma pack
C、#pragma data_seg
D、#pragma once

12、若有定义；int a[8];，则以下表达式中不能代表数组元素a[1]的地址的是（）。

A、&a[0]+1
B、&a[1]
C、&a[0]++
D、a+1

13、若有说明：int a[][4]={0,0};，则下面不正确的叙述为（）

A、数组 a 中的每个元素都可以得到初值 0
B、二维数组 a 的第一维大小为 1
C、数组 a 的行数为 1
D、只有数组元素 a[0][0] 和 a[0][1] 可以得到初值 0，其余元素的初值无法确定。

14、若有以下程序
1
2
3
4
5
6
7
#include <stdio.h>
#define SUB( X,Y ) (X+1)*Y
main( )
{ 
    int a=3,b=4;
    printf( "%d\n" ,SUB( a++ ,b++ ) );
}

程序运行后的输出结果是?

A、25 B、20 C、12 D、16

15、若有定义；int a=7；float x=2.5，y=4.7；则表达式x+a%3 * (int)(x+y)%2/4的值是（）。

A、2.500000
B、2.750000
C、3.500000
D、0.000000

16、若有下面的说明和定义：
1
2
3
4
5
6
7
8
9
struct test{ 
    int ml;
    char m2;
    float m3;
    union uu{
        char ul[5]; 
        int u2[2];
    } ua;
} myaa;

则sizeof(struct test )的值是（ ）。

A、20 B、16 C、14 D、9

17、在32位操作系统中，我们定义如下变量 int ( * n)[10]; 请问调用函数sizeof(n),返回值为（）

A、4 B、40 C、8 D、80

18、下面代码会输出()
1
2
3
4
5
6
int main()
{
    int a[4]={1,2,3,4};
    int *ptr=(int*)(&a+1);
    printf("%d",*(ptr-1));
}

A、4 B、1 C、2 D、3

19、哪个选项可以将下面的t初始化为当前程序的运行时间？
1
time_t t;

A、t = clock();
B、time( &t );
C、time( t );
D、t = localtime();
E、None of the above

20、若 k 为 int 型变量，则以下程序段的执行结果是（）。
1
2
k=-8567; 
printf("|%06D|\n",k);

A、格式描述符不合法,输出无定值

B、输出为|%06D|

C、输出为|0-8567|

D、输出为|-8567|

答案与解析：

1 2 3 4 5 6
D D BC AB C B
7 8 9 10 11 12
A C C C B C
13 14 15 16 17 18
D D A A A A
19 20
A B
1、答案：D。

解析：第一题考察了关于进程的基本知识。

首先，什么是进程？进程是程序的执行实体，是系统资源进行资源分配的基本单位，我们经常拿进程和线程进行对比。线程是任务调度和执行的基本单位，一个进程可以由多个线程组成。我们平时写的程序，一般都只是一个进程，除非程序员手动创建一个新的进程，比如使用fork函数（进程创建方式不止这一种）。

由fork创建的新进程被称为子进程。fork函数被调用一次，但是返回两次，一次是父进程的返回值一次是子进程的，两次返回的区别是子进程的返回值是0，父进程的返回值则是新建子进程的进程ID。这时候的子进程就会共享父进程的代码资源，拷贝一份父进程的资源，然后创建属于自己的堆栈等数据空间。也就是说，这时候子进程和父进程都会继续执行fork调用之后的指令。

说到这里，我们就可以解决第一个问题了。程序循环fork了5次，第一次只有一个父进程调用fork，创建一个子进程，这时候共有2个进程。然后第二次循环时，这两个进程分别创建一个子进程，共有4个进程。同理,3次循环有8个进程，4次有16,5次就有32个。


2、答案：D。

解析：第二题是一个基本的二级指针定义问题。

既然是定义，记住就好。

定义基类型为int的三个指针变量:int pt1,int pt2,int * pt3;

定义一个基类型为int的具有三个元素的指针数组pt：int *pt[3]

定义一个名为 pt、具有三个元素的整型数组:名字叫 pt的数组？没法定义。

定义一个名为pt的指针变量，它可以指向每行有三个整数元素的二维数组:int ( * pt)[3];

所以：B和D的区别，就是 * 和谁在一起，和int在一起，就说明元素是指针，和变量在一起，就说明变量是指针。


3、答案：B C。

解析：第三题考察了输入输出规则。

对于浮点型和字符串%m.n含义不同。浮点型：m表示输出位数，n表示精度，也就是小数点后面几位。对于字符串，表示输出字符的个数。

4、答案：A B。

解析：不要忘记数组做函数参数的时候会退化成指针哟，所以B也是对的，另外D是C++引用的写法，即使是C++环境下，D也是不对的，因为引用不能用指针的形式调用，而且 char &name表示的是一个字符，应该是char &name[]。

5、答案：C

解析：printf(“%x,%o,”,ch,ch,k);中虽然输出项不匹配，但是不会死机，K会被忽略，%x表示16进制输出，%o表示8进制输出。%%是输出%的转换表示。所以输出%d。

6、答案：B

A:真是非0，假是0
C:x==y对于浮点型变量来讲是合法的
D:分支的判断是根据表达式的结果，不是算数表达式

7、答案：A

unsigned int 类型在32位为系统上占4个字节，一个字节8位，就是32位，32个二进制相当于8个16进制（4个2进制是一个16进制）。

所以完全表示是：0x00001234。大端小端的表示是以一个字节表示的。大端表示低地址存储高位。

大端：00 00 12 34（从左到右，地址递增，&a从低位开始）

小端：34 12 00 00

所以&a是char型的地址，占一个字节：00。所以b=0x00。

8、答案：C

是不是会一不小心选择了A，注意应该是乘法。不要忘记bit和B之间的转换。

1024 640 16bit=1024 640 2B= 640 * 2KB=1280KB。

9、答案：C

读写难道不应该选择D吗？这里考察了文件读写的几种模式：

表示 含义
r read的简写，表示只读打开，文件必须存在
r+ 读写打开文件，文件必须存在，写的意思是覆盖之前的文件
rt 只读打开文本文件，文件必须存在
rt+ 读写打开文本文件，文件必须存在
rb 只读打开二进制文件，文件必须存在
rb+ 读写打开二进制文件，文件必须存在
w 只写打开文件，文件存在清空它，不存在创建它。
w+ 读写打开文件，文件存在清空它，不存在创建它。
wt 只写打开文本文件，文件存在清空它，不存在创建它。
wt+ 读写打开文本文件，文件存在清空它，不存在创建它。
wb 只写打开二进制文件，文件存在清空它，不存在创建它。
wb+ 读写打开二进制文件，文件存在清空它，不存在创建它。

综上：+表示读写，w表示文件可以不存在。

10、答案：C

A：void*
B：错
D：整数也是不能直接赋值给指针变量的，必须强制转换成对应的指针类型。

11、答案：B

在所有的预处理指令中#pragma 可能是最复杂的了。

#pragma comment。将一个注释记录放置到对象文件或可执行文件中。

#pragma pack。用来改变编译器的字节对齐方式。

#pragma code_seg。它能够设置程序中的函数在obj文件中所在的代码段。在驱动开发中会用到

#pragma once。保证所在文件只会被包含一次

12、答案：C

A：&a[0]+1表示元素a[0]的地址加1，也就是a[1]的地址;
B：&a[1]当然表示a[1]的地址
C：&a[0]++包含有对&a[0]的赋值运算，本身是非法的
D：a+1表示数组a的首地址（即a[0]的地址）加1，也是a[1]的地址

13、答案：D

数组初始化原则是：只要对数组中元素部分初始化，剩余元素都被编译器默认初始化为0.所以A对D不对，二维数组a中初值的个数不能被第二维大小的值整除,则第一维的大小等于所得商数再加1,故数组a的行数为1

14、答案：D

#define XXX YYY,表达式XXX会在预处理阶段处理，直接进行替换。所以程序就变成了：
printf( “%d\n” ,(a++ +1) b++)),其中a++在括号里面，先加在取值，b++则先取值再加，结果就是：4 4=16。

15、答案：A

%的优先级和 / 是相等的，所以注意从左向右
x+a%3 (int)(x+y) % 2 / 4=2.5+7%3 (int)(7.2) % 2 / 4=2.5+1 7%2/4=2.5+0=2.5

16、答案：A

这道题考察了结构体和联合体的字节对齐规则：联合体的规则比较简单，因为它的所有成员变量都共用同一块内存，所以整个联合体的内存大小就是最大成员所占的内存大小。
结构体会按照成员的顺序依次分配，也就是说可能两个结构体成员的定义都是相同的，只是顺序不一样，那么这两个结构体需要的内存空间有可能不一样。
当轮到某一个成员时，如果此时的内存偏移量不是该成员所需内存的倍数时，则需要扩充到满足位置，所有成员都分配完成后，如果此时内存块大小不是最大成员大小的倍数时，也需要扩充。

注意，数组是按照一个元素来算的。

本题中，各成员所需要的内存大小是：
int ml：4；char m2：1；float m3：4； char ul[5]：5；int u2[2]：8；
最开始的偏移量为：0，这时候是4的0倍，不需要补齐，所以是+4；偏移量变为：4；
4是1的倍数，所以+1，偏移量变为：5；
5不是4的倍数，补齐+3，偏移量变为：8，是4的2倍，所以+4，偏移量变为：12；
联合体的内存大小是：8,按照单个元素4来算，12是4的倍数，直接+4*2，变为：20。

当然，还有另外一种算法是直接算出对齐的单位，不足就补齐：对齐方式由 编译器的対界方式 和 自身的対界方式 取较小的那一个编译器的対界方式默认为8，可以以宏的方式进行设置#pragma pack(x) x为对齐的字节大小本题中没有设置编译器，固为默认的8，而自身的対界方式如下：
struct(还有union,class)的対界方式为最大的数据成员的大小：在struct里面为4(int)，在union里面也为4(int),
综合判断4 < 8，固对齐方式为4个字节

接下来看sizeof(struct test)的大小，除union部分外
sizeof(int)+size(char)+sizeof(float) = 4 + 1 + 4 = 9
对union来说大小为成员定义里面最大的那个
5sizeof(char) = 5 < 2sizrof(int) = 8;
固union的sizeof(union uu)为 8 ,
因此总的大小为 9 + 8 = 17，考虑到对齐的方式为4字节，
因此向开界20对齐。答案为 A

17、答案：A

区分一下这两个：
int( n)[10]; 是数组指针 sizeof(n)=4；
int n[10]; 是指针数组 sizeof(n)=40；
本题可以结合第二题一起练习。

18、答案：A

考察对于数组和指针的认识，指针加一的能力由类型决定。intptr=(int)(&a+1); &a 和a 都指的是数组首元素的地址。不同的是
a就是a+0 ， （a+0）就是a[0],而&a+1 相当于a[]数组类型的指针加1，此时指针加到数组的末尾。
ptr接受后，由于Ptr的类型是int 因此ptr-1 即回退4字节。即指到最后一个元素。

19、答案：A

clock()就是该程序从启动到函数调用占用CPU的时间

time( &t );为获取系统时间

localtime(&t); 将一个UTC时间转为本地时间

20、答案：B

%06d意思是将要输出的整数按六位输出，不足六位的用零补齐。但是此题的d大写成D，因此不选C。

1
2