c语言面试题

bill
文档
2024-07-06
117热度
0评论

下面是小编整理的c语言面试题，本文共12篇，希望对大家有所帮助。

c语言面试题

11. 指向常量的指针和常指针的区别

答案：指向常量的指针所指向的内容不能被修改但能够指向其它的量，而常指针是指向的内容可以被修改但指针不能再指向其它地方。

12. if (a=b)

printf(“a==b”)

else

printf(“a!=b”);

输出结果为：

A.a==b B.a!=b C.不一定 D.不能运行

答案：不一定，这要根据b的内容来决定。通常再编程时不要使用此类的赋值语句。

13.在内联函数中使用static变量，比如

inline test

{ static couter = 0;

counter++;

}

会有什么问题?

答案：会造成多次定义该变量，因此再内联函数中禁止定义静态变量

14. F是一个结构类型，有如下定义：

F f1,f2;

问：f1=f2;语句是否成立?

答案：该语句成立，不过有的编译器不支持。实际上编译器也是用内存拷贝函数来实现的。

15.全局变量、局部变量、模块变量在内存空间中如何存放?(数据区or栈空间?)

答案：全局变量在全局空间分配，局部变量在栈空间分配，模块变量在全局空间分配。

16.struct A{

......

union {

int x;

.....

};

}

struct A a;

问：a.x这样的表示法是否成立?

答案：成立

如果结构定义改为如下定义

.struct A{

......

int x;

union {

int x;

.....

};

}

那a.x表示法是否成立?

答案：不成立，编译时会报x变量重定义

17. #define REDEF(name,arg1,arg...)

_##name (arg1,##arg)

问：以下两个语句宏展开的结果

REDEF(test_fn1,int a,int b);

REDEF(test_fn2,int a);

答案：

_test_fn1(int a ,int b)

_test_fn2(int a);

注意：在VC中不支持，gcc才支持该参数宏函数。

18. fnxxxx_max(char str[])

{

putchar str[0];

str++; //(1)

printf(“%s”,str);

}

main()

{

char str[20]={“ABCDEFG”};

fnxxxx_max(str);

str++; //(2)

printf(“%s”,str);

}

问：语句(1)和语句(2)是否成立?

答案：语句(1)成立，语句(2)不成立

19.#define SRR 0x001;

#define SRT 0x002;

#define SRI 0x0900;

EVENT = SRR|SRT|SRI

问：上面的语句有什么问题?EVENT的值会是多少?

答案：宏展开后变为：

EVENT = 0x001; 0x002;0x0900;

因此EVENT的值为0x001,所以在编程时一定要小心，一定不要在常量宏定义的后面加上分号。

c语言基础面试题

1、statac 全局变量、局部变量、函数与普通全局变量、局部变量、函数static 全局变量与普通的全局变量有什么区别?static 局部变量和普通局部变量有什么区别?static 函数与普通函数有什么区别?

答、全局变量(外部变量)的说明之前再冠以 static 就构成了静态的全局变量，全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。

这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。

从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。

static 函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件static 全局变量与普通的全局变量有什么区别：static 全局变量只初使化一次，防止在其他文件单元中被引用;

static 局部变量和普通局部变量有什么区别：static 局部变量只被初始化一次，下一次依据上一次结果值;

static 函数与普通函数有什么区别：static 函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

2、程序的内存分配

答：一个由 c/C++编译的程序占用的内存分为以下几个部分

1、栈区(stack)—由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

2、堆区(heap)—一般由程序员分配释放，若程序员不释放，程序结束时可能由 OS 回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。

3、全局区(静态区)(static)—全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。

4、文字常量区—常量字符串就是放在这里的。程序结束后由系统释放。

5、程序代码区—存放函数体的二进制代码

3、解释堆和栈的区别

答：堆(heap)和栈(stack)的区别

(1)申请方式

stack:由系统自动分配。例如，声明在函数中一个局部变量 int b;系统自动在栈中为 b 开辟空间

heap:需要程序员自己申请，并指明大小，在 c 中 malloc 函数

如 p1=(char*)malloc(10);

在 C++中用 new 运算符

如 p2=(char*)malloc(10);

但是注意 p1、p2 本身是在栈中的。

(2)申请后系统的响应

栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。

堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的 delete 语句才能正确的释放本内存空间，

另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

(3)申请大小的限制

栈：在 Windows 下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS 下，栈的大小是 2M(也有的说是 1M，总之是一个编译时就确定的常数)，如果申请的空间超过栈的.剩余空间时，将提示 overflow。因此，能从栈获得的空间较小。

堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

(4)申请效率的比较：

栈:由系统自动分配，速度较快。但程序员是无法控制的。

堆:是由 new 分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.另外，在 WINDOWS 下，最好的方式是用 Virtual Alloc 分配内存，他不是在堆，也不是在栈,而是直接在进程的地址空间中保留一块内存，虽然用起来最不方便。但是速度快，也最灵活。

(5)堆和栈中的存储内容

栈：在函数调用时，第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的地址，然后是函数的各个参数，在大多数的 C 编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。

当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。

堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。

(6)存取效率的比较

char s1[]=“aaaaaaaaaaaaaaa”;

char *s2=“bbbbbbbbbbbbbbbbb”;

aaaaaaaaaaa 是在运行时刻赋值的;

而 bbbbbbbbbbb 是在编译时就确定的;

但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。

比如：

#include

voidmain()

{

char a=1;

char c[]=“1234567890”;

char *p=“1234567890”;

a = c[1];

a = p[1];

return;

}

对应的汇编代码

10:a=c[1];

004010678A4DF1movcl,byteptr[ebp-0Fh]

0040106A884DFCmovbyteptr[ebp-4],cl

11:a=p[1];

0040106D8B55ECmovedx,dwordptr[ebp-14h]

004010708A4201moval,byteptr[edx+1]

004010738845FCmovbyteptr[ebp-4],al

第一种在读取时直接就把字符串中的元素读到寄存器 cl 中，而第二种则要先把指针值读到 edx 中，在根据 edx 读取字符，显然慢了。

c语言面试题及答案

一、选择题(1)～(10)每小题2分，(11)～(50)每小题1分，共60分)

在下列各题A)、B)、C)、D)四个选项中，只有一个选项是正确的，请将正确的选项涂写在答题卡相应的位置上，答在试卷上不得分。

(1)在数据结构中，从逻辑上可以把数据结构分为_______。

A)动态结构和静态结构 B)紧凑结构和非紧凑结构

C)线性结构和非线性结构 D)内部结构和外部结构

答案：C

评析：逻辑结构反映数据元素之间的逻辑关系，线性结构表示数据元素之间一对一的关系，非线性结构表示数据元素之间一对多或多对一的关系。

(2)若进栈序列为l，2，3，4，进栈过程中可以出栈，则下列选项中不可能的一个出栈序列是_______。

A)1，4，3，2 B)2，3，4，l

C)3，1，4，2 D)3，4, 2，1

答案：C

评析：栈是一种后进先出表，在选项c中，先出栈的是3，说明此时栈内必然有1，2，由于l先于2进栈，所以l不可能在2之前出栈，故选项C这种出栈序列是不可能的。

(3)排序方法中，将整个无序序列分割成若干小的子序列并分别进行插入排序的方法，称为_______。

A)希尔排序 B)冒泡排序 C)插入排序 D)选择排序

答案：A

评析：希尔排序法的基本思想是：将整个无序序列分割成若干小的子序列分别进行插入排序。

(4)在顺序表(3，6，8，10，12，15，16，18，21，25，30)中，用二分法查找关键码值11，所需的关键码比较次数为_______。

A)2 B)3 C)4 D)5

答案：C

评析：二分法查找是用关键码与线性表的中间元素比较，然后根据比较结果来判断是结束查找，还是在左边或者右边子表按相同的方法继续查找。本题中，与ll比较的关键码分别为15，8，10，12四个。

(5)对于n个结点的单向链表(无表头结点)，需要指针单元的个数至少为_______。

A)n-1 B)n C)n+l D)2n

答案：C

评析：在n个结点的单向链表(无表头结点)中，每个结点都有一个指针单元(即指针域)，加上头指针，至少需要n+1个指针单元。

(6)在软件开发过程中，软件结构设计是描述_______。

A)数据存储结构 B)软件体系结构 C)软件结构测试 D)软件控制过程

答案：B

评析：从工程管理的角度来看，软件设计分为两步完成：概要设计和详细设计。概要设计(又称结构设计)将软件需求转化为软件体系结构、确定系统级接口、全局数据结构或数据库模式。

(7)模块本身的内聚是模块独立性的重要性度量因素之一。在7类内聚中，具有最强内聚的一类是_______。

A)顺序性内聚 B)过程性内聚 C)逻辑性内聚 D)功能性内聚

答案：D

评析：内聚性是一个模块内部各元素间彼此结合的紧密程度的度量。内聚共有7类，它们之间的内聚性由弱到强排列顺序为：偶然内聚、逻辑内聚、时间内聚、过程内聚、通信内聚、顺序内聚和功能内聚。

(8)数据存储和数据流都是_______，仅仅是所处的状态不同。

A)分析结果 B)事件 C)动作 D)数据

答案：D

评析：数据流图有4种成分：源点或终点、处理、数据存储和数据流。数据存储是处于静止状态的数据，数据流是处于运动中的数据。

(9)数据的完整性是指数据的正确性、有效性和_______。

A)可维护性 B)独立性 C)安全性 D)相容性

答案：D

评析：数据模型的完整性规则是给定的数据模型中数据及其联系所具有的制约和依存规则，用以限定符合数据模型的数据库状态及其状态的变化，以保证数据的正确性、有效性和相容性。

(10)关系代数运算是以_______为基础的运算。

A)关系运算 B)谓词运算 C)集合运算 D)代数运算

答案：C

评析：关系代数运算是以关系代数作为运算对象的一组高级运算的集合。它的基本操作是并、交、差、笛卡尔积，另外还包垂直分割(投影)、水平分割(选择)、关系的结合(连接)等。

(11)能将高级语言程序转换成目标语言程序的是_______。

A)调试程序 B)解释程序 C)编译程序 D)编辑程序

答案：C

评析：用高级语言编写的程序称为“源程序”，而计算机只能识别和执行由0和l组成的二进制指令，所以高级语言必须先用一种称为“编译程序”的软件，把源程序翻译成二进制形式的“目标程序”。

(12) _______是构成c语言程序的基本单位。

A)函数 B)过程 C)子程序 D)子例程

答案：A

评析：c程序是由函数构成的。一个c源程序至少包含一个main函数，也可以包含一个main函数和若干个其他函数，因此，函数是c程序的基本单位。

(13)可以在C语言中用做用户标识符的是_______。

A)void B)as_b3 C)for D)2c

define _123 -abc Do

WORD If cas SIG

答案：B

评析：在c语言中规定，标识符只能由字母、数字和下划线三种符号所组成，而且第一个字符必须是字母或下划线。另外还需要注意的是关键字不能作标识符。选项A中void，C中for都为关键字，D中2c以字母开头。

(14)若有以下类型说明语句：

char w；int x；float y，z；

则表达式w*x+z-y的结果为________类型。

A)float B)char C)int D)double

答案：A

评析：在进行运算时，不同类型的数据参加运算，需要先将其转换成同一类型的数据，然后再进行运算。转换的顺序由低到高为：char，short→int→unsigned→long→double→float，故结果为float型。

(15)main(

{ float x=123A56；

printf(“％-5．2f”,x)；

}

以上程序输出的结果是________。

A)123．4 B)123．5 C)123．45 D)123．46

答案：D

评析：f格式符，用来输出实数，以小数的形式输出。“％-m．nf”的含义是：输出数据共占m列，其中n位小数，如果输出位数小于m。则右端补空格。如果总长度大于列数，则按实际情况四舍五入输出。

(16)下面语句的输出结果是________。

Printf(“％d＼n”,strlen(“＼t＼”＼065＼xff＼n”))；

A)14 B)8

C)5 D)输出项不合法，无正常输出

答案：C

评析：在c语言中，以“＼”开头的字符均为转义字符，其中“＼”后可跟l～3位八进制数或在“＼”后跟字母x及l～2位十六进制数，以此来代表一个特定的字符。

(17)下列程序的输出结果是________。

main()

{ int a=0，b=0，c=0；

if(++a>0lI++b>0)++c；

printf(“＼na=％d，b=％d，c=％d”，a，b，C)；

}

A)a=0,b=0，c=0 B)a=l，b=l，c=1

C)a=l,b=O, c=I D)a=0, b=1．c=1

答案：C

评析：

“︱︱”是或运算，它有个“短路”的特点需要特别注意，当“︱︱”运算符左边的表达式的值为真时，则程序就不再对“︱︱”右边的表达式的值去进行运算，而是使得整个表达式的值直接为真。

(18)下列程序的输出结果是_________。

Main()

{ int i；

for(i=1；i+l；i++)

{ if(i>4){printlf(”％d”，i++)；break；}

}

printf(“％d”，i++)；

}

A)55 B)56

C)程序错误，没有输出 D)循环条件永远为真，死循环

答案：B

评析：本程序中有个for循环，但注意到for循环的条件是“i+l”，也就是只要i+l的值为真(非零值均为真)，就执行循环。当i=l的时，i+l的值为真，判断if条件不成立，执行i++，输出i的值为5。

(19)下列程序的输出结果是_________。

#define A 100

main()

{ int i=O,sum=O；

do{ if(I==(i／2)*2)continue；

sum+=i；

}while(++i

printf(“％d＼n”,sum)；

}

A)2500 B)2050 C)4 D)O

答案：A

评析：本题程序的功能是求1到_99之问(包括1和99)所有奇数之和。程序中的while循环的终止条件为++i=100，在while循环体内，如果i是偶数，则执行continue，跳过这一次循环，去执行下一次循环，否则求和。最后输出的值是1到99之间(包括l和99)所有奇数之和(1+99)*50／2=2500。

(20)下列程序的输出结果是_________。

main()

{ int I=3；

switch(i)

{ case 1：

case 2：printf(”％d”，i)；

case 3：

case 4：break；

default：printf(”OK”)；

}

A)0 B)3 C)OK D)没有任何输出

答案：D

评析：在本题中，i的值为3，由于“case 3：”后面没有break语句，所以继续向下执行“case 4：”后面的语句，由于“case 4：”后面的语句为break强行退出switch语句，所以，本题没有任何输出。

(21)下列程序执行后的输出结果是________。

main()

{ int m[][3]={1,4,7,2,5,8,3,6,9}；

int i，k=2：

for(I=0；i

{printf(”％d”，m[k][i])；}

}

A)456 B)258 C)369 D)789

答案：C

评析：根据二维数组的定义得出：m[O][O]=1，m[O][1]=4，m[O][2]=7，m[1][0]=2，rail][1]=5，m[1][2]=8，m[2][0]=3，m[2][l]=6，m[2][2]=9，所以本题的输出是第3行的值m[2][0]，m[2][1]，m[2][2]，即369。

(22)设已定义洱口k为int类型变量，则以下for循环语句_________。

for(i=0；k=-1，k=1；i++，k++)

printf(”****＼n”)；

A)判断循环结束的条件不合法 B)是无限循环

C)循环一次也不执行 D)循环只执行一次

答案：B

评析：本题定义了一个for循环，它的循环变量是i，但由于本题并没有去设置循环条件，所以循环的条件永远默认为真，即无限次执行循环。

(23)下面程序的输出结果是___________。

unsigned fun(unsigned num)

{ unsigned k=1；

do{

k*=num％lO；

num／=lO；

}while(num)；

return(k)；

}

main()

{ unsigned n。26；

printf(”％d＼n”,fun(n))；

}

A)0 B)4 C)12 D)无限次循环

答案：C

评析：本题定义了一个fun函数，用于num求和，具体执行过程如下：

num=26：k=k*(num％10)=1*(26％10)，所以k=6，num=num／10=2；

num=2：k=k*(num％10)=6*(2％10)，所以k=12，num=num／lO=O；

num=O：while条件不成立，所以返回k的值12．

(24)已知字母A的ASCII码值是65，字母a的ASCII码值是97，以下程序_______。

main()

{ char a=‘A’；

int b=20；

printf(“％d，％o”，(a=a+a,a+b,b)，a+‘a’-‘A’，b)；

}

A)表达式非法，输出零或不确定值

B)因输出项过多，无输出或输出不确定值

C)输出结果为20,141

D)输出结果为20,141,20

答案：C

评析：本题中首先输出逗号表达式“a=a+a，a+b，b”的值，即是20。然后以八进制的形式输出a+‘a’-‘A’的值为97对应的八进制数141，由于最后一个表达式b没有对应输出格式的输出项表列就不会输出。

(25)C语言函数返回值的类型是由__________决定的。

A)return语句中的表达式类型 B)调用函数的主调函数类型

C)调用函数时临时 D)定义函数时所指定的函数类型

答案：D

评析：函数值的类型应当是在定义函数时指定的。在定义函数时对函数值说明的类型一般应该和return语句中的表达式类型一致，如果不_致，则以函数类型为准，即函数类型决定返回值的类型。

(26)下列程序执行后输出的结果是___________。

int d=l：

fun(int p)

{ int d。5；

d+=p++；

printf(”％d，”，d)；

}

main()

{ int a=3；

fun(a)；

d+=a++：

printf(”％d＼n”，d)；

}

A)8，12 B)9，13 C)8,4 D)9,5

答案：C

评析：本题执行过程如下：首先调用fun函数，使得实参a的值3传递给形参p，得到局部变量d=8，打印出局部变量d的值8；返回主函数执行“d+=a++”，此处的d为全局变量，所以d=1+3=4(由于本题是值传递，所以在函数fun中对p值的改变并不能引起a的改变)，故本题的输出是8,4。

(27)已知下面的程序段，正确的判断是_________。

#define A 3

#define B(A)((_A+1)‘a)

int a=3：

……

X=3*(A+B(7))；

A)程序错误，不允许嵌套定义 B)X=93

C)X=8l D)程序错误，宏定义不允许有参数

答案：C

评析：本题的宏定义是合法的，宏定义展开为3*(3+((A+1)*a))=3*(3+((7+1)*3))=81。

(28)定义int*swap()指的是_______。

A)一个返回整型值的函数swap()

B)一个返回指向整型值指针的函数swap()

C)一个指向函数swap()的指针，函数返回一个整型值

D)以上说法均错

答案：B

评析：一个函数可以带回一个整型值、字符值、实型值等，但是也可以带回指针型数据，即地址。本题的定义中，包括括号和·号，由于f)优先级高于t。故它是一个返回整型指针的函数。

(29)以下程序段的输出结果是__________。

main()

{ char s1[10]，s2[10]，s3[10]；

scanf(”％s”，s1)；gets(s2)；gets(s3)；

puts(s 1)；puts(s2)；puts(s3)；

}

输入数据如下： (此处代表回车符)

aaa

bbb

A)aaa B)aaa C)aaa＼0bbb＼0 D)aaabbb

bbb

答案：B

评析：scanf是标准的输入函数，在输入字符串aaa时，实际的内容为“aaa”，“＼0”是由系统自动加入的；gets的功能是从终端读入一行字符，即一直读到换行符为止，并由系统自动以“＼0”代替换行符。

(30)下述函数功能是________。

Int fun(char*x)

{ char*y=x；

while(*y++)；

return y-x-l；

}

A)求字符串的长度 B)求字符串存放的位置

C)比较两个字符串的大小 D)将字符串x连接到字符串y后面

答案：A

评析：在函数体内定义一字符型指针并指向形参，然后遍历其中各字符直到碰到NULL，最后返回字符串首尾地址的差值，即字符串的长度。

(31)以下程序的输出结果是_________。

main()

{ char str[12]={‘s’,‘t’,‘r’,‘i’,‘n’,‘ g’}；

printf(”％d＼n”,strlen(str))；

}

A)6 B)7 C)ll D)12

答案：A

评析：在c语言中，字符串的长度是其首字符到NULL(不含)字符的总字符个数。本题定义字符数组str的同时，对第7个元素，由系统自动添加上“＼0”，故字符串的长度为6。

(32)请读程序段：

char str[]=”ABCD”,*p=str；

printf(”％d＼n”，*(p+4))；

程序段的输出结果是_________。

A)68 B)0

C)字符‘D’的地址 D)不确定的值

答案：B

评析：在对字符数组赋字符串值时，系统会自动在字符串的末尾加上一个字符串结束标志“＼0”，故指向字符数组的指针p的+(p+4)的值为“＼0”。由于“＼0”的编码值就是0，所以本题输出为0。

(33)若有定义：int a[4][10]；，则以下选项中对数组元素a[i][j]引用错误的是________。

A)*(＆a[O][O]+10*i+j) B)*(a+i)+j

C)*(*(a+i)+j) D)*(a[i]+j)

答案：B

评析：本题中选项B是错误的引用，*(a+i)+j只代表了a[i][i]的地址。

(34)设有以下语句：

char strl[]=”string”，str2[8]，。str3，。str4=”strin∥；

则__________不是对库函数的正确调用。

A)strcpy(strl，”HELLOl”)； B)strcpy(str2，”HELL02”)；

C)strcpy(str3，”HELL03”)； D)strcpy(str4,”HELL04”)；

答案：C

评析：c语言中：sgcpy(stl,st2)；，其两个参数均为字符指针或字符数组，选项c中的目的`串指针str3没有指向具体有效的存储单元，故是错误的调用。

(35)请读程序：

#include

main()

{ char*sl=”AbCdEf”，*s2=”aB”；

s1++；s2++；

printf(”％d＼n”,strcmp(s 1，s2))；

}

上面程序的输出结果是___________。

A)正数 B)负数 C)零 D)不确定的值

答案：A

评析：函数strcmp的功能是比较字符串s1和s2，如果sl>s2，则返回个正数；如果sls2，所以函数的值为正数。

(36)下面程序的输出是_________。

char s[]=”ABcD”；

main()

{ char*p；

for(p=s；p

printf(”％s＼n”，p)；

}

A)ABCD B)A C)D D)ABCD

BCD B C ABC

CD C B AB

D D A A

答案：A

评析：在第一次执行for循环的时候，字符数组的首地址赋给了指针变量p，使得指针变量p指向了s的首地址，输出p所指向的字符串；第二次执行for循环时，p值增加1，p指向了s的第二个元素输出BCD；第三次输出CD；第四次输出D；直到p指向字符串的结束字符“＼0”，for循环终止执行。

(37)以下程序输出的结果为__________。

main()

{ char* alpha[6]={“ABCD”，EFGH”，”IJKL”，”MNOP”，”QRST”，”UVwX”}；

char**p；

int i：

p=alpha；

for(I=0；i

printf(”％s”，p[I])；

}

A)ABCDEFGHIJKL B)ABCD

C)ABCDEFGHIJKLMNOP D)AEIM

答案：C

评析:alpha[O]指向“ABCD”的首地址；alpha[1]指向“EFGH”的首地址；alpha[2]指向“IJKL”的首地址，依此类推。当执行到p=alpha后，p指向指针数组alpha的首地址。for循环中输出了4个字符串。

(38)下面程序的输出结果是_________。

#include

main()

{ char*p[]={”B00L”，”0PK”，”H”，”SP”}；

int i：

for(i=3；i>=0；i–,i–)

printf(“％c”,*p[i])；

printf(”＼n”)；

}

A)SO B)SP C)SPOPK D)SHOB

答案：A

评析：p[0]存放的是“BOOL＼0”的首地址；p[1]存放的是“OPK＼0”的首址等。

在printf语句中输出的+p[I]表示p[i]字符串的第一个字符。在for循环中，i的初值为3，那么输出的第一个字符为“s”，接着两次i–，则输出的值为+p[1]，即字符“0”，所以本题的输出为SO。

(39)以下程序的输出结果是_________。

#include

void prt(int*x,int*y,int*z)

{ printf(”％d，％d，％d＼n”，++*x，++*y*(z++))；}

int a=10,b=40,c=20；

main()

{ prt(&a，&b&C)；

prt(&a，&b，&C)；

}

A)ll,42,3l B)ll,41,20 C)1l,21,40 D)11,41，2l

12,22,41 12,42,20 11,2l,41 12,42,22

答案：B

评析：由于实参传送的是变量的地址，所以对形参指针所指向的单元内容的改变，即对实参内容的改变。

(40)若一个外部变量的定义形式为static int x；，那么，其中static的作用应该是_______。

A)将变量存储在静态存储区

B)使变量x可以由系统自动初始化

C)使x只能在本文件内引用

D)使x的值可以永久保留

答案：C

评析：事实上，无论有无static修饰，外部变量都具有A、B和c三种特性。作为一种修饰，static仅是限制此类型外部变量的引用范围：只能在定义它的文件范围内使用。

(41)以下程序的输出结果是________。

#include

#define SQR(x)x*x

main()

{ int a，k=3；

a=++SQR(k+1)；

printf(”％d＼n”，a)；

}

A)8 B)9 C)17 D)20

答案：B

评析：本题宏替换中遇到形参x以实参k+l代替，其它字符不变。sQR(k+1)展开后应为字符串k+l*k+l。

(42)下面是对宏定义的描述，不正确的是_______。

A)宏不存在类型问题，宏名无类型，它的参数也无类型

B)宏替换不占用运行时间

C)宏替换时先求出实参表达式的值，然后代入形参运算求值

D)宏替换只不过是字符替代而已

答案：C

评析：宏替换实质上就是字符替代，它不可能去进行计算，故c是错误的。带参数的宏与函数相比，宏在程序编译之前已经将代码替换到程序内，执行时不会产生类似于函数调用的问题，可以说不占用运行时间。

(43)以下程序(程序左边的数字为附加的行号)________。

1#include

2#include

3main()

4{char s[]=”string”；

5 puts(s)；

6 strcpy(s,”hello”)；

7 printf(”％3s＼n”，s)；}

A)没有错 B)第l行有错 C)第6行有错 D)第7行有错

答案：B

评析：字符串复制函数strcpy包含在头文件string．h中，因此，程序中的第l行文件包含命令是错误的。

(44)若有如下说明，则__________的叙述是正确的。

struct st

{ int a；

int b[2l；

}a；

A)结构体变量a与结构体成员a同名，定义是非法的

B)程序只在执行到该定义时才为结构体st分配存储单元

C)程序运行时为结构体st分配6个字节存储单元

D)类型名struct st可以通过extern关键字提前引用(即引用在前，说明在后)

答案：D

评析：结构体变量a与结构体成员a同名是合法的定义，引用成员a的方法是a．a，变量a处于不同的“层次”上，系统完全能够分清。st是一个结构体名，不会为结构体名分配存储空间，应该是在运行时为结构体变量a分配6个字节的存储单元，故选项B和选项C错误。

(45)若有以下结构体定义，则________是正确的引用或定义。

struct example

{ int x；

int y；

}v1；

A)example．x=10 B)example v2．x=10

C)struct v2；v2．x=lO D)struct example v2={10}；

答案：D

评析：在定义结构体变量时，不能只用结构体名example或关键字strum进行定义，必需要用结构体类型名struct example定义，在引用结构体成员变量时，需要用结构体变量名进行引用，所以选D。

(46)下列程序的执行结果是_________。

#include

union un

{ int i；

char c[21；

}；

void main()

{ union un x；

x．c[0]=10：

x．c[1]=1：

printf(“＼n％d”,x．i)；

}

A)266 B)ll C)265 D)138

答案：A

评析：由于本题定义的是共用体，所以成员表列中的整型变量x和字符数组c共占用同一个存储单元，且此存储单元为2个字节，通常c[O]位于低字节，c[1]位于高字节，所以x．i的值为266。

(47)已知形成链表的存储结构如下图所示，则下述类型描述中的空白处应填_______。

struct link

Datanext{ char data；

___________

}node；

A)struct link next B)link*next

C)struct next link D)struct link*next

答案：D

评析：在单向链表中，由于每个结点需要存储下一个结点的地址，且下一个结点的数据类型与前一个结点的数据类型完全相同，故应为struct link*next。

(48)已知小写字母a的ASCII码为97，大写字母A的ASCII．码为65，以下程序的结果是__________。

main()

{ unsigned int a=32,b=66；

printf(“％c＼n”,atb)；

}

A)66 B)98 C)b D)B

答案：C

评析：位运算符“l”的作用是按位或，即两个二进制数的相应位中只要有一个为1，该位的结果值为l。最后以字符型输出， 98对应的字符“b”。

(49)C语言库函数龟ets(str,n,fp)的功能是_________。

A)从fp指向的文件中读取长度n的字符串存入str指向的内存

B)从fp指向的文件中读取长度不超过n-l的字符串存入str指向的内存

C)从fp指向的文件中读取n个字符串存／Xstr指向的内存

D)从str读取至多n个字符到文件fp

答案：B

评析：fgets函数的作用是从指定的文件读入一个字符串。fgets(str,n,fp)；中的n为要求得到的字符的个数，但只从fb指向的文件输入n-1个字符，然后在最后加一个‘＼O’字符，因此得到的字符串共有n个字符。

(50)下述的程序向文件输出的结果是__________。

#include

void main()

{ FILE*fp=fopen(“TEST”,”wb”)；

fprintf(fp,”％d％5．0f％c％d”,58,76273．0,’-',2278)；

fclose(fp)；

}

A)58 76273-2278 B)5876273。．000000-2278

C)5876273-2278 D)因文件为二进制文件而不可读

答案：C

评析：fprintf函数工作时，多个数据间不会自动加分隔符，选项A错误；浮点数的输出格式是“％5．0f”表明其小数部分输出O位，即没有输出，所以选项B也是错误的。

二、填空题(每空2分，共40分)

请将每个空的正确答案写在【l】至【20】序号的横线上，答在试卷上不得分。

(1)对于长度为n的顺序存储的线性表，当随机插入和删除一个元素时，需平均移动元素的个数为【l】。

答案：【1】n／2

评析：删除一个元素，平均移动的元素个数为(n-l+n-2+……+0)n=(n-1)／2；插入一个元素，平均移动元素个数为(n+n-l+n-2+……+1)n=(n+1)／2；所以总体平均移动元素个数为n／2。

(2)注释说明了程序的功能，它分为【2】注释和功能性注释。

答案：【2】序言性

评析：注释一般分为序言性注释和功能性注释。

(3)软件测试中路径覆盖测试是整个测试的基础，它是对软件【3】进行测试。

答案：【3】结构

评析：路径测试是白盒测试方法中的一种，它要求对程序中的每条路径最少检查一次，目的是对软件的结构进行测试。

(4)数据库技术的主要特点为数据的集成性、数据的高【4】和低冗余性、数据独立性和数据统一管理与控制。

答案：【4】共享性

评析：数据库技术的主要特点有以下几个方面：数据的集成性，数据的高共享性与低冗余性，数据韵独立性，数据统一管理与控制。

(5)数据元素之间【5】的整体称为逻辑结构。

答案：【5】逻辑关系

评析：数据元素之间逻辑关系的整体称为逻辑结构。数据的逻辑结构就是数据的组织形式。

(6)若有定义int m=5,y=2，则执行表达式y+=y-=m*=y后，y的值为【6】。

答案：【6】．16

评析：将赋值运算符右侧的“表达式”的值赋给左侧的变量，并且赋值运算符按照“白右而左”的结合顺序，本题表达式应先算m的值为10，再运算y的值为8，最后计算y=y+(-8)=-8+(-8)=-16。

(7)若x和y都是double型变量，]ix的初值为3．0，y的初值为2．0，则表达式pow(y，fabs(x))的值为【7】。

答案：【7】8．000000

评析： fabs函数功能是求x的绝对值，计算结果为double型。pow功能是计算x的y次方的值，计算结果同样为double型。所以本题表达式相当于2．0的3．0次方，结果为8．000000。

(8)设有char a，b；，若要通过a&b运算屏蔽掉a中的其它位，只保留第2位和第8位(右起为第1位)，则b的二进制是【8】。

答案：【8】10000010

评析：运算“&”的规则是只有当两个相应的二进制位都为1时，该位的结果才为1。要保留第2、8位，只要将其与二进制数10000010相与。

(9)下列程序执行后输出的结果是【9】。

f(int a)

{ static c=0；

C=a+C++：

return(C)；

}

main()

{ int a=2，i，k；

for(i=O；i

k=f(a++)；

printf(”％d＼n”，k)；

}

答案：【9】7

评析：在程序执行时，static变量仅初始化一次，下次使用时将使用上次保存的值。

(10)下面程序执行后输出的结果是【10】。

int m=13：

int fun(int x，int y)

{ int m=3；

return(x*y-m)；

}

main()

{ int a=7,b=5；

printf(”％d＼n”,fun(a，b)／m)；

}

答案：【10】2

评析：本题变量m既是外部变量(值是13)，又是fun函数的局部变量(值为3)。函数fun(x*y-m)的值为7*5-3=32，在main函数中，ftm(a,b)／m中的m应取外部变量的值13，因此输出2。

(11)下列程序执行后输出的结果是【11】。

main()

{ nt arr[10],i，k=0；

for(I=0；i

for(I=1；i

printf(”％d＼n”，k)；

}

答案：【11】12

评析：本题的第一个for循环是用于给数组arr赋初值，第二个for循环用于求和运算。由于第二个for循环初始值为1，而循环条件为i

(12)下列程序执行后输出的结果是【12】。

struct s

{int x，y；}data[2]={10,100,20,200}；

main()

{

struct s*p=data；

printf(”％d”，++(p->x))；

}

答案：【12】11

评析：程序中结构体数组data首地址(即&data[0])赋值给结构体指针变量p，++(p->x)表示先将p所指向的结构体变量的成员x值加1，然后将此x(即data[01．x]输出。

(13)下面程序有两个printf语句，如果第一个printf语句输出的是194，则第二个print语句的输出结果是【13】。

main()

{ int a [10]={1,2,3,4,5,6,7,8,9,0}，*p；

p=a；

printf(”％X＼n”，p)；

printf(”％x＼n”，p+9)；

}

答案：【13】la6

评析:对于指针变量的运算，就是对于地址的运算。本题中由于指针指向的是整型变量，所以，使指针变量移动9个位置也就是移动18个字节。注意，本题是以16进制输出的。

(14)以下函数的功能是计算s=l+l／2!+l／3!+…+l／n!，请填空.

double fun(int n)

{ double s=O．O,fac=1．O；

int i，k=1；

for(i=l；i

{ 【14】；

fat=fat／k；

s=s+fac；

}

答案：【14】k=k*i

评析：本题中通过for循环求s表达式中每一项的和，表达式“fac=fac／k；”求的是每一项的值，所以k的值应为n!，在求n!的时候，可以用上次循环阶乘的值乘i，就可以直接得此次n!，故本题填k=k*i。

(15)下面程序的运行结果是【15】。

main()

{ unsigned a=0112,x；

x=a>>3：

printf(”x=％o”，x)；

}

答案：【15】x=11

评析：在对无符号数的右移是高位补0。

(16)函数(s,i,n)是作用是从字符串s中删除从第i个字符开始的n个字符，请填空。

void (char s[]，int i,int n)

{ int j，k,length=O；

while(s[1ength])

【16】；

–i：

j=i；

}

if( 【17】 )

{ k=i+n；

if(i+n

while(k

s[j++]=s[k++]；

s[j]=‘＼0’;

}

答案：【16】length++

【17】i

评析：第一个循环极有可能是这个计算串的长度，在i

(17)下述函数统计一个字符串中的单词个数，单词是指处在空格之间的字符序列，请填空。

int word(char*s)

{ int num=O,flag=O；

while(*s)

{ if( 【18】 ==”)flag=O；

else if( 【19】 ){flag=1；num++}

}

return 【20】；

}

答案：【18】*s++

【19】flag==O或*（s-1）==”

【20】num

评析：在统计字符串单词个数的算法中，本题的flag是为了记录一个单词是否结束了。在第18空应填写*s++；如果某个字符不是空格，则必需判断它是否是单词，如果是，则使得flag的标志为1，num的值加1。本题判断方法是：先判断s所指向的字符是否为空格，如果是则使得flag=O，否则判断前一个字符是否是空格，如果是的话，则说明这个字符是一个单词的开始，将flag标志为1，num的值加1，如果不是，则不必记录。故第19空应flag==O或*(s-1)==”；最后一个空格需填写的是返回的单词的个数，即num。

篇4：c语言面试题笔试题

预处理器(Preprocessor)

1. 用预处理指令#define 声明一个常数，用以表明1年中有多少秒(忽略闰年问题)

#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL

我在这想看到几件事情：

1). #define 语法的基本知识(例如：不能以分号结束，括号的使用，等等)

2). 懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。

3). 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。

4). 如果你在你的表达式中用到UL(表示无符号长整型)，那么你有了一个好的起点。记住，第一印象很重要。

2. 写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。

#define MIN(A,B) ((A)

这个测试是为下面的目的而设的：

1). 标识#define在宏中应用的基本知识。这是很重要的，因为直到嵌入(inline)操作符变为标准C的一部分，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。

2). 三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。

3). 懂得在宏中小心地把参数用括号括起来

4). 我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事?

least = MIN(*p++, b);

3. 预处理器标识#error的目的是什么?

如果你不知道答案，请看参考文献1。这问题对区分一个正常的伙计和一个书呆子是很有用的。只有书呆子才会读C语言课本的附录去找出象这种问题的答案。当然如果你不是在找一个书呆子，那么应试者最好希望自己不要知道答案。

死循环(Infinite loops)

4. 嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢?

这个问题用几个解决方案。我首选的方案是：

while(1)

{

}

一些程序员更喜欢如下方案：

for(;;)

{

}

这个实现方式让我为难，因为这个语法没有确切表达到底怎么回事。如果一个应试者给出这个作为方案，我将用这个作为一个机会去探究他们这样做的

基本原理。如果他们的基本答案是：“我被教着这样做，但从没有想到过为什么。”这会给我留下一个坏印象。

第三个方案是用 goto

Loop:

...

goto Loop;

应试者如给出上面的方案，这说明或者他是一个汇编语言程序员(这也许是好事)或者他是一个想进入新领域的BASIC/FORTRAN程序员。

数据声明(Data declarations)

5. 用变量a给出下面的定义

a) 一个整型数(An integer)

b) 一个指向整型数的指针(A pointer to an integer)

c) 一个指向指针的的指针，它指向的指针是指向一个整型数(A pointer to a pointerto an integer)

d) 一个有10个整型数的数组(An array of 10 integers)

e) 一个有10个指针的数组，该指针是指向一个整型数的(An array of 10 pointers tointegers)

f) 一个指向有10个整型数数组的指针(A pointer to an array of 10 integers)

g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数(A pointer to a function that takes an integer as an argument and returns an integer)

h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数( An array of ten pointers to functions that take an integer argument and return an integer )

答案是：

a) int a; // An integer

b) int *a; // A pointer to an integer

c) int **a; // A pointer to a pointer to an integer

d) int a[10]; // An array of 10 integers

e) int *a[10]; // An array of 10 pointers to integers

f) int (*a)[10]; // A pointer to an array of 10 integers

g) int (*a)(int); // A pointer to a function a that takes an integer argumentand returns an integer

h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer

人们经常声称这里有几个问题是那种要翻一下书才能回答的问题，我同意这种说法。当我写这篇文章时，为了确定语法的正确性，我的确查了一下书。但是当我被面试的时候，我期望被问到这个问题(或者相近的问题)。因为在被面试的这段时间里，我确定我知道这个问题的答案。应试者如果不知道所有的答案(或至少大部分答案)，那么也就没有为这次面试做准备，如果该面试者没有为这次面试做准备，那么他又能为什么出准备呢?

Static

6. 关键字static的作用是什么?

这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：

1). 在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。

2). 在模块内(但在函数体外)，一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。

3). 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。

大多数应试者能正确回答第一部分，一部分能正确回答第二部分，同是很少的人能懂得第三部分。这是一个应试者的严重的缺点，因为他显然不懂得本地化数据和代码范围的好处和重要性。

Const

7.关键字const是什么含意?

我只要一听到被面试者说：“const意味着常数”，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：EmbeddedSystems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着“只读”就可以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。(如果你想知道更详细的答案，仔细读一下Saks的文章吧。)如果应试者能正确回答这个问题，我将问他一个附加的问题：下面的声明都是什么意思?

const int a;

int const a;

const int *a;

int * const a;

int const * a const;

前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针(也就是，整型数是不可修改的，但指针可以)。第四个意思a是一个指向整型数的常指针(也就是说，指针指向的整型数是可以修改的，但指针是不可修改的)。最后一个意味着a是一个指向常整型数的常指针(也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的)。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢?我也如下的几下理由：

1). 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。(当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。)

2). 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。

3). 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。

Volatile

8. 关键字volatile有什么含意并给出三个不同的例子。

一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：

1). 并行设备的硬件寄存器(如：状态寄存器)

2). 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)

3). 多线程应用中被几个任务共享的变量回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。嵌入式系统程序员经常同硬件、中断、RTOS等等打交道，所用这些都要求volatile变量。不懂得volatile内容将会带来灾难。假设被面试者正确地回答了这是问题(嗯，怀疑这否会是这样)，我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。

1). 一个参数既可以是const还可以是volatile吗?解释为什么。

2). 一个指针可以是volatile 吗?解释为什么。

3). 下面的函数有什么错误：

int square(volatile int *ptr)

{

return *ptr * *ptr;

}

下面是答案：

1). 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

2). 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。

3). 这段代码的有个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：

int square(volatile int *ptr)

{

int a,b;

a = *ptr;

b = *ptr;

return a * b;

}

由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值!正确的代码如下：

long square(volatile in

[c语言面试题笔试题]

篇5：思科和慧通的c语言笔试面试题

思科

1. 用宏定义写出swap(x，y)

#define swap(x, y)

x = x + y;

y = x - y;

x = x - y;

2.数组a[N]，存放了1至N-1个数，其中某个数重复一次，写一个函数，找出被重复的数字.时间复杂度必须为o(N)函数原型：

int do_dup(int a[],int N)

3 一语句实现x是否为2的若干次幂的判断

int i = 512;

cout

4.unsigned int intvert(unsigned int x,int p,int n)实现对x的进行转换,p为起始转化位,n为需要转换的长度,假设起始点在右边.如x=0b0001 0001,p=4,n=3转换后x=0b0110 0001

unsigned int intvert(unsigned int x,int p,int n){

unsigned int _t = 0;

unsigned int _a = 1;

for(int i = 0; i

_t |= _a;

_a = _a

}

_t = _t

x ^= _t;

return x;

}

慧通：

什么是预编译

何时需要预编译：

1、总是使用不经常改动的大型代码体。

2、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，可以将所有包含文件预编译为一个预编译头。

char * const p;

char const * p

const char *p

上述三个有什么区别?

char * const p; //常量指针，p的值不可以修改

char const * p;//指向常量的指针，指向的常量值不可以改

const char *p; //和char const *p

char str1[] = “abc”;

char str2[] = “abc”;

const char str3[] = “abc”;

const char str4[] = “abc”;

const char *str5 = “abc”;

const char *str6 = “abc”;

char *str7 = “abc”;

char *str8 = “abc”;

cout

结果是：0 0 1 1

解答：str1,str2,str3,str4是数组变量，它们有各自的内存空间;

而str5,str6,str7,str8是指针，它们指向相同的常量区域，

12. 以下代码中的两个sizeof用法有问题吗?[C易]

void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母

{

for( size_t i=0; i

if( “a”

str[i] -= (“a”-“A” );

}

char str[] = “aBcDe”;

cout

UpperCase( str );

cout

答：函数内的sizeof有问题。根据语法，sizeof如用于数组，只能测出静态数组的大小，无法检测动态分配的或外部数组大小。函数外的str是一个静态定义的数组，因此其大小为6，函数内的str实际只是一个指向字符串的指针，没有任何额外的与数组相关的信息，因此sizeof作用于上只将其当指针看，一个指针为4个字节，因此返回4。

一个32位的机器,该机器的指针是多少位

指针是多少位只要看地址总线的位数就行了。80386以后的机子都是32的数据总线。所以指针的位数就是4个字节了。

main

{

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

int *ptr=(int *)(&a+1);

printf(“%d,%d”,*(a+1),*(ptr-1));

}

输出：2,5

*(a+1)就是a[1]，*(ptr-1)就是a[4],执行结果是2，5

&a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小(本例是5个int)

int *ptr=(int *)(&a+1);

则ptr实际是&(a[5]),也就是a+5

原因如下：

&a是数组指针，其类型为 int (*)[5];

而指针加1要根据指针类型加上一定的值，

不同类型的指针+1之后增加的大小不同

a是长度为5的int数组指针，所以要加 5*sizeof(int)

所以ptr实际是a[5]

但是prt与(&a+1)类型是不一样的(这点很重要)

所以prt-1只会减去sizeof(int*)

a,&a的地址是一样的，但意思不一样，a是数组首地址，也就是a[0]的地址，&a是对象(数组)首地址，a+1是数组下一元素的地址，即a[1],&a+1是下一个对象的地址，即a[5].

1.请问以下代码有什么问题：

int main()

{

char a;

char *str=&a;

strcpy(str,“hello”);

printf(str);

return 0;

}

没有为str分配内存空间，将会发生异常

问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果，但因为越界进行内在读写而导致程序崩溃。

char* s=“AAA”;

printf(“%s”,s);

s[0]=“B”;

printf(“%s”,s);

有什么错?

“AAA”是字符串常量。s是指针，指向这个字符串常量，所以声明s的时候就有问题。

cosnt char* s=“AAA”;

然后又因为是常量，所以对是s[0]的赋值操作是不合法的。

篇6：2023c语言面试题

考查的是结构体和数组的内存布局情况。

#include

typedef struct array1{

int ID;

struct array1__ next;

}A;

typedef struct array2{

int ID;

int a;

int b;

int c;

}__ B;

int main

{

A s1[15];

A__ s2;

B s3;

for(int i=0;i

{

s1[i].ID=i+64;

}

s2=s1+3;

s3=(B)s2;

printf(“%d/n”,s3->b);

return 0;

}

篇7：2023c语言面试题

C语言中sizeof的用法

void fun(char s[10])

{

printf(“%s/n”,s);

printf(“%d/n”,sizeof(s));//引用的大小

}

int main

{

char str={“sasdasdes”};

printf(“%d/n”,sizeof(str));//字符串数组的大小10(包含了字符'/0')

printf(“%d/n”,strlen(str)));//字符串的长度9

char __p=str;

printf(“%d/n”,sizeof(p));//指针的大小4

printf(“%d/n”,strlen(p));//字符串的长度9

fun(str);

void __h=malloc(100);

char ss[100]=“abcd”;

printf(“%d/n”,sizeof(ss));//字符串数组的大小100

printf(“%d/n”,strlen(ss));//字符串的长度4

printf(“%d/n”,sizeof(h));//指针的大小4

}

篇8：C语言面试题大12

1、用指针的方法，将字符串“ABCD1234efgh”前后对调显示

#include

int main

{

char str[] = “ABCD1234efgh”;

int length = strlen(str);

char * p1 = str;

char * p2 = str + length - 1;

while(p1

{

char c = *p1;

*p1 = *p2;

*p2 = c;

++p1;

--p2;

}

printf(“str now is %s”,str);

system(“pause”);

return 0;

}

2、有一分数序列：1/2,1/4,1/6,1/8……，用函数调用的方法，求此数列前20项的和

#include

double getValue()

{

double result = 0;

int i = 2;

while(i

{

result += 1.0 / i;//一定要使用1.0做除数，不能用1，否则结果将自动转化成整数，即0.000000

i += 2;

}

return result;

}

int main()

{

printf(“result is %f”, getValue());

system(“pause”);

return 0;

}

Top

回复人：free131(白日?做梦!) ( ) 信誉：100 -4-17 10:18:33 得分:0

有一个数组a[1000]存放0--1000;要求每隔二个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置，

以7个数为例：

{0,1,2,3,4,5,6,7} 0-->1-->2(删除)-->3-->4-->5(删除)-->6-->7-->0(删除)，如此循环直到最后一个数被删除。

方法1：数组

#include

using namespace std;

#define null 1000

int main()

{

int arr[1000];

for (int i=0;i

arr[i]=i;

int j=0;

int count=0;

while(count

{

while(arr[j%1000]==null)

j=(++j)%1000;

while(arr[j%1000]==null)

j=(++j)%1000;

while(arr[j%1000]==null)

j=(++j)%1000;

arr[j]=null;

++count;

}

while(arr[j]==null)

j=(++j)%1000;

cout

return 0;

}方法2：链表

#include

using namespace std;

#define null 0

struct node

{

int data;

node* next;

};

int main()

{

node* head=new node;

head->data=0;

head->next=null;

node* p=head;

for(int i=1;i

{

node* tmp=new node;

tmp->data=i;

tmp->next=null;

head->next=tmp;

head=head->next;

}

head->next=p;

while(p!=p->next)

{

p->next->next=p->next->next->next;

p=p->next->next;

}

cout

return 0;

}

方法3：通用算法

#include

#define MAXLINE 1000 //元素个数

MAXLINE 元素个数

a[] 元素数组

R[] 指针场

suffix 下标

index 返回最后的下标序号

values 返回最后的下标对应的值

start 从第几个开始

K 间隔

int find_n(int a[],int R[],int K,int& index,int& values,int s=0) {

int suffix;

int front_node,current_node;

suffix=0;

if(s==0) {

current_node=0;

front_node=MAXLINE-1;

}

else {

current_node=s;

front_node=s-1;

}

while(R[front_node]!=front_node) {

printf(“%d”,a[current_node]);

R[front_node]=R[current_node];

if(K==1) {

current_node=R[front_node];

continue;

}

for(int i=0;i

front_node=R[front_node];

}

current_node=R[front_node];

}

index=front_node;

values=a[front_node];

return 0;

}

int main(void) {

int a[MAXLINE],R[MAXLINE],suffix,index,values,start,i,K;

suffix=index=values=start=0;

K=2;

for(i=0;i

a[i]=i;

R[i]=i+1;

}

R[i-1]=0;

find_n(a,R,K,index,values,2);

printf(“the value is %d,%d”,index,values);

return 0;

}

试题：

void test2()

{

char string[10], str1[10];

int i;

for(i=0; i

{

str1[i] = “a”;

}

strcpy( string, str1 );

}

解答：对试题2，如果面试者指出字符数组str1不能在数组内结束可以给3分;如果面试者指出strcpy(string, str1)调用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10 分;

str1不能在数组内结束:因为str1的存储为：{a,a,a,a,a,a,a,a,a,a},没有“”(字符串结束符)，所以不能结束

strcpy( char *s1,char *s2)他的工作原理是，扫描s2指向的内存，逐个字符付到s1所指向的内存，直到碰到“”,因为str1结尾没有“”，所以具有不确定性，不知道他后面还会付什么东东，

正确应如下

void test2()

{

char string[10], str1[10];

int i;

for(i=0; i

{

str1[i] = “a”+i; //把abcdefghi赋值给字符数组

}

str[i]=“”;//加上结束符

strcpy( string, str1 );

}

第二个code题是实现strcmp

int StrCmp(const char *str1, const char *str2)

做是做对了，没有抄搞，比较乱

int StrCmp(const char *str1, const char *str2)

{

assert(str1 && srt2);

while (*str1 && *str2 && *str1 == *str2) {

str1++, str2++;

}

if (*str1 && *str2)

return (*str1-*str2);

elseif (*str1 && *str2==0)

return 1;

elseif (*str1 = = 0 && *str2)

return -1;

else

return 0;

}

int StrCmp(const char *str1, const char *str2)

{

//省略判断空指针(自己保证)

while(*str1 && *str1++ = = *str2++);

return *str1-*str2;

}

第三个code题是实现子串定位

int FindSubStr(const char *MainStr, const char *SubStr)

做是做对了，没有抄搞，比较乱

int MyStrstr(const char* MainStr, const char* SubStr)

{

const char *p;

const char *q;

const char * u = MainStr;

//assert((MainStr!=NULL)&&( SubStr!=NULL));//用断言对输入进行判断

while(*MainStr) //内部进行递增

{

p = MainStr;

q = SubStr;

while(*q && *p && *p++ == *q++);

if(!*q )

{

return MainStr - u +1 ;//MainStr指向当前起始位，u指向

}

MainStr ++;

}

return -1;

}

分析：

int arr[] = {6,7,8,9,10};

int *ptr = arr;

*(ptr++)+=123;

printf(“ %d %d ”, *ptr, *(++ptr));

输出：8 8

过程：对于*(ptr++)+=123;先做加法6+123，然后++，指针指向7;对于printf(“ %d %d ”, *ptr, *(++ptr));从后往前执行，指针先++，指向8，然后输出8，紧接着再输出8

篇9：C语言面试题大13

1. 有双向循环链表结点定义为：

struct node

{ int data;

struct node *front,*next;

};

有两个双向循环链表A，B，知道其头指针为：pHeadA,pHeadB，请写一函数将两链表中data值相同的结点删除

BOOL DeteleNode(Node *pHeader, DataType Value)

{

if (pHeader == NULL) return;

BOOL bRet = FALSE;

Node *pNode = pHead;

while (pNode != NULL)

{

if (pNode->data == Value)

{

if (pNode->front == NULL)

{

pHeader = pNode->next;

pHeader->front = NULL;

}

else

{

if (pNode->next != NULL)

{

pNode->next->front = pNode->front;

}

pNode->front->next = pNode->next;

}

Node *pNextNode = pNode->next;

delete pNode;

pNode = pNextNode;

bRet = TRUE;

//不要break或return, 删除所有

}

else

{

pNode = pNode->next;

}

return bRet;

}

void DE(Node *pHeadA, Node *pHeadB)

{

if (pHeadA == NULL || pHeadB == NULL)

{

return;

}

Node *pNode = pHeadA;

while (pNode != NULL)

{

if (DeteleNode(pHeadB, pNode->data))

{

if (pNode->front == NULL)

{

pHeadA = pNode->next;

pHeadA->front = NULL;

}

else

{

pNode->front->next = pNode->next;

if (pNode->next != NULL)

{

pNode->next->front = pNode->front;

}

Node *pNextNode = pNode->next;

delete pNode;

pNode = pNextNode;

}

else

{

pNode = pNode->next;

}

2. 编程实现：找出两个字符串中最大公共子字符串,如“abccade”,“dgcadde”的最大子串为“cad”

int GetCommon(char *s1, char *s2, char **r1, char **r2)

{

int len1 = strlen(s1);

int len2 = strlen(s2);

int maxlen = 0;

for(int i = 0; i

{

for(int j = 0; j

{

if(s1[i] == s2[j])

{

int as = i, bs = j, count = 1;

while(as + 1

count++;

if(count >maxlen)

{

maxlen = count;

*r1 = s1 + i;

*r2 = s2 + j;

}

3. 编程实现：把十进制数(long型)分别以二进制和十六进制形式输出，不能使用printf系列库函数

char* test3(long num) {

char* buffer = (char*)malloc(11);

buffer[0] = “0”;

buffer[1] = “x”;

buffer[10] = “”;

char* temp = buffer + 2;

for (int i=0; i

temp[i] = (char)(num>28);

temp[i] = temp[i] >= 0 ? temp[i] : temp[i] + 16;

temp[i] = temp[i]

}

return buffer;

}

输入N, 打印 N*N 矩阵

比如 N = 3，打印：

1 2 3

8 9 4

7 6 5

N = 4，打印：

1 2 3 4

12 13 14 5

11 16 15 6

10 9 8 7

解答：

1 #define N 15

int s[N][N];

void main()

{

int k = 0, i = 0, j = 0;

int a = 1;

for( ; k

{

while( j

while( i

while( j >k-1 ) s[i][j--] = a++; i--; j++;

while( i >k ) s[i--][j] = a++; i++; j++;

}

for( i = 0; i

{

for( j = 0; j

cout

}

2 define MAX_N 100

int matrix[MAX_N][MAX_N];

*(x,y)：第一个元素的坐标

* start：第一个元素的值

* n：矩阵的大小

void SetMatrix(int x, int y, int start, int n) {

int i, j;

if (n

return;

if (n == 1) { //矩阵大小为1时

matrix[x][y] = start;

return;

}

for (i = x; i

matrix[y][i] = start++;

for (j = y; j

matrix[j][x+n-1] = start++;

for (i = x+n-1; i >x; i--) //底部

matrix[y+n-1][i] = start++;

for (j = y+n-1; j >y; j--) //左部

matrix[j][x] = start++;

SetMatrix(x+1, y+1, start, n-2); //递归

}

void main() {

int i, j;

int n;

scanf(“%d”, &n);

SetMatrix(0, 0, 1, n);

//打印螺旋矩阵

for(i = 0; i

for (j = 0; j

printf(“%4d”, matrix[i][j]);

printf(“”);

}

斐波拉契数列递归实现的方法如下：

int Funct( int n )

{

if(n==0) return 1;

if(n==1) return 1;

retrurn Funct(n-1) + Funct(n-2);

}

请问，如何不使用递归，来实现上述函数?

请教各位高手!

解答：int Funct( int n ) // n 为非负整数

{

int a=0;

int b=1;

int c;

if(n==0) c=1;

else if(n==1) c=1;

else for(int i=2;i

{

c=a+b;

a=b;

b=c;

}

return c;

}

解答：

现在大多数系统都是将低字位放在前面，而结构体中位域的申明一般是先声明高位，

C语言面试题大汇总13

，

100 的二进制是 001 100 100

低位在前高位在后

001----s3

100----s2

100----s1

所以结果应该是 1

如果先申明的在低位则：

001----s1

100----s2

100----s3

结果是 4

1、原题跟little-endian，big-endian没有关系

2、原题跟位域的存储空间分配有关，到底是从低字节分配还是从高字节分配，从Dev C++和VC7.1上看，都是从低字节开始分配，并且连续分配，中间不空，不像谭的书那样会留空位

3、原题跟编译器有关，编译器在未用堆栈空间的默认值分配上有所不同，Dev C++未用空间分配为

01110111b，VC7.1下为11001100b,所以在Dev C++下的结果为5，在VC7.1下为1。

注：PC一般采用little-endian，即高高低低，但在网络传输上，一般采用big-endian，即高低低高，华为是做网络的，所以可能考虑big-endian模式，这样输出结果可能为4

判断一个字符串是不是回文

int IsReverseStr(char *aStr)

{

int i,j;

int found=1;

if(aStr==NULL)

return -1;

j=strlen(aStr);

for(i=0;i

if(*(aStr+i)!=*(aStr+j-i-1))

{

found=0;

break;

}

return found;

}

Josephu 问题为：设编号为1，2，… n的n个人围坐一圈，约定编号为k(1

数组实现：

#include

int Josephu(int n, int m)

{

int flag, i, j = 0;

int *arr = (int *)malloc(n * sizeof(int));

for (i = 0; i

arr[i] = 1;

for (i = 1; i

{

flag = 0;

while (flag

{

if (j == n)

j = 0;

if (arr[j])

++flag;

++j;

}

arr[j - 1] = 0;

printf(“第%4d个出局的人是：%4d号”, i, j);

}

free(arr);

return j;

}

int main()

{

int n, m;

scanf(“%d%d”, &n, &m);

printf(“最后胜利的是%d号!”, Josephu(n, m));

system(“pause”);

return 0;

}

链表实现：

#include

typedef struct Node

{

int index;

struct Node *next;

}JosephuNode;

int Josephu(int n, int m)

{

int i, j;

JosephuNode *head, *tail;

head = tail = (JosephuNode *)malloc(sizeof(JosephuNode));

for (i = 1; i

{

tail->index = i;

tail->next = (JosephuNode *)malloc(sizeof(JosephuNode));

tail = tail->next;

}

tail->index = i;

tail->next = head;

for (i = 1; tail != head; ++i)

{

for (j = 1; j

{

tail = head;

head = head->next;

}

tail->next = head->next;

printf(“第%4d个出局的人是：%4d号”, i, head->index);

free(head);

head = tail->next;

}

i = head->index;

free(head);

return i;

}

int main()

{

int n, m;

scanf(“%d%d”, &n, &m);

printf(“最后胜利的是%d号!”, Josephu(n, m));

system(“pause”);

return 0;

}

已知strcpy函数的原型是：

char * strcpy(char * strDest,const char * strSrc);

1.不调用库函数，实现strcpy函数。

2.解释为什么要返回char *。

解说：

1.strcpy的实现代码

char * strcpy(char * strDest,const char * strSrc)

{

if ((strDest==NULL)||(strSrc==NULL)) file://[/1]

throw “Invalid argument(s)”; //[2]

char * strDestCopy=strDest; file://[/3]

while ((*strDest++=*strSrc++)!=“”); file://[/4]

return strDestCopy;

}

错误的做法：

[1]

(A)不检查指针的有效性，说明答题者不注重代码的健壮性。

(B) 检查指针的有效性时使用((!strDest)||(!strSrc))或(!(strDest&&strSrc))，说明答题者对C语言中类型的隐式转换没有深刻认识。在本例中char *转换为bool即是类型隐式转换，这种功能虽然灵活，但更多的是导致出错概率增大和维护成本升高。所以C++专门增加了bool、true、false 三个关键字以提供更安全的条件表达式。

(C)检查指针的有效性时使用((strDest==0)||(strSrc==0))，说明答题者不知道使用常量的好处。直接使用字面常量(如本例中的0)会减少程序的可维护性。0虽然简单，但程序中可能出现很多处对指针的检查，万一出现笔误，编译器不能发现，生成的程序内含逻辑错误，很难排除。而使用NULL代替0，如果出现拼写错误，编译器就会检查出来。

[2]

(A)return new string(“Invalid argument(s)”);，说明答题者根本不知道返回值的用途，并且他对内存泄漏也没有警惕心。从函数中返回函数体内分配的内存是十分危险的做法，他把释放内存的义务抛给不知情的调用者，绝大多数情况下，调用者不会释放内存，这导致内存泄漏。

(B)return 0;，说明答题者没有掌握异常机制。调用者有可能忘记检查返回值，调用者还可能无法检查返回值(见后面的链式表达式)。妄想让返回值肩负返回正确值和异常值的双重功能，其结果往往是两种功能都失效。应该以抛出异常来代替返回值，这样可以减轻调用者的负担、使错误不会被忽略、增强程序的可维护性。

[3]

(A)忘记保存原始的strDest值，说明答题者逻辑思维不严密。

[4]

(A)循环写成while (*strDest++=*strSrc++);，[1](B)。

(B)循环写成while (*strSrc!=“”) *strDest++=*strSrc++;，说明答题者对边界条件的检查不力。循环体结束后，strDest字符串的末尾没有正确地加上“”。

篇10：C语言面试题大11

1. 简述一个Linux驱动程序的主要流程与功能，

2. 请列举一个软件中时间换空间或者空间换时间的例子。

void swap(int a,int b)

{

int c; c=a;a=b;b=a;

}

--->空优

void swap(int a,int b)

{

a=a+b;b=a-b;a=a-b;

}

6. 请问一下程序将输出什么结果?

char *RetMenory(void)

{

char p[] = “hellow world”;

return p;

}

void Test(void)

{

char *str = NULL;

str = RetMemory;

printf(str);

}

RetMenory执行完毕，p资源被回收，指向未知地址。返回地址，str的内容应是不可预测的, 打印的应该是str的地址

写一个函数,它的原形是int continumax(char *outputstr,char *intputstr)

功能：

在字符串中找出连续最长的数字串，并把这个串的长度返回，并把这个最长数字串付给其中一个函数参数outputstr所指内存。例如：“abcd12345ed125ss123456789”的首地址传给intputstr后，函数将返回

9，outputstr所指的值为123456789

int continumax(char *outputstr, char *inputstr)

{

char *in = inputstr, *out = outputstr, *temp, *final;

int count = 0, maxlen = 0;

while( *in != “” )

{

if( *in >47 && *in

{

for(temp = in; *in >47 && *in

count++;

}

else

in++;

if( maxlen

{

maxlen = count;

count = 0;

final = temp;

}

for(int i = 0; i

{

*out = *final;

out++;

final++;

}

*out = “”;

return maxlen;

}

不用库函数,用C语言实现将一整型数字转化为字符串

方法1：

int getlen(char *s){

int n;

for(n = 0; *s != “”; s++)

n++;

return n;

}

void reverse(char s[])

{

int c,i,j;

for(i = 0,j = getlen(s) - 1; i

c = s[i];

s[i] = s[j];

s[j] = c;

}

void itoa(int n,char s[])

{

int i,sign;

if((sign = n)

n = -n;

i = 0;

do{/*以反序生成数字*/

s[i++] = n%10 + “0”;/*get next number*/

}while((n /= 10) >0);/*delete the number*/

if(sign

s[i++] = “-”;

s[i] = “”;

reverse(s);

}

方法2:

#include

using namespace std;

void itochar(int num);

void itochar(int num)

{

int i = 0;

int j ;

char stra[10];

char strb[10];

while ( num )

{

stra[i++]=num%10+48;

num=num/10;

}

stra[i] = “”;

for( j=0; j

{

strb[j] = stra[i-j-1];

}

strb[j] = “”;

cout

}

int main()

{

int num;

cin>>num;

itochar(num);

return 0;

}

前几天面试，有一题想不明白,请教大家!

typedef struct

{

int a:2;

int b:2;

int c:1;

}test;

test t;

t.a = 1;

t.b = 3;

t.c = 1;

printf(“%d”,t.a);

printf(“%d”,t.b);

printf(“%d”,t.c);

谢谢!

t.a为01,输出就是1

t.b为11，输出就是-1

t.c为1，输出也是-1

3个都是有符号数int嘛，

这是位扩展问题

编译器进行符号扩展

求组合数：求n个数(1....n)中k个数的组合....

如：combination(5,3)

要求输出：543，542，541，532，531，521，432，431，421，321，

#include

int pop(int *);

int push(int );

void combination(int ,int );

int stack[3]={0};

top=-1;

int main()

{

int n,m;

printf(“Input two numbers:”);

while( (2!=scanf(“%d%*c%d”,&n,&m)) )

{

fflush(stdin);

printf(“Input error! Again:”);

}

combination(n,m);

printf(“”);

}

void combination(int m,int n)

{

int temp=m;

push(temp);

while(1)

{

if(1==temp)

{

if(pop(&temp)&&stack[0]==n) //当栈底元素弹出&&为可能取的最小值，循环退出

break;

}

else if( push(--temp))

{

printf(“%d%d%d ”,stack[0],stack[1],stack[2]);

pop(&temp);

}

int push(int i)

{

stack[++top]=i;

if(top

return 0;

else

return 1;

}

int pop(int *i)

{

*i=stack[top--];

if(top>=0)

return 0;

else

return 1;

}

篇11：C语言面试题大10

同学的4道面试题，应聘的职位是搜索引擎工程师，后两道超级难，(希望大家多给一些算发)

1.给两个数组和他们的大小，还有一动态开辟的内存，求交集，把交集放到动态内存dongtai，并且返回交集个数

long jiaoji(long* a[],long b[],long* alength,long blength,long* dongtai[])

2.单连表的建立，把“a”--“z”26个字母插入到连表中，并且倒叙，还要打印!

方法1：

typedef struct val

{ int date_1;

struct val *next;

}*p;

void main(void)

{ char c;

for(c=122;c>=97;c--)

{ p.date=c;

p=p->next;

}

p.next=NULL;

}

方法2：

node *p = NULL;

node *q = NULL;

node *head = (node*)malloc(sizeof(node));

head->data = “ ”;head->next=NULL;

node *first = (node*)malloc(sizeof(node));

first->data = “a”;first->next=NULL;head->next = first;

p = first;

int longth = “z” - “b”;

int i=0;

while ( i

{

node *temp = (node*)malloc(sizeof(node));

temp->data = “b”+i;temp->next=NULL;q=temp;

head->next = temp; temp->next=p;p=q;

i++;

}

print(head);

3.可怕的题目终于来了

象搜索的输入信息是一个字符串，统计300万输入信息中的最热门的前十条，我们每次输入的一个字符串为不超过255byte,内存使用只有1G,

请描述思想，写出算发(c语言)，空间和时间复杂度，

4.国内的一些帖吧，如baidu,有几十万个主题，假设每一个主题都有上亿的跟帖子，怎么样设计这个系统速度最好，请描述思想，写出算发(c语言)，空间和时间复杂度，

#include string.h

main(void)

{ char *src=“hello,world”;

char *dest=NULL;

dest=(char *)malloc(strlen(src));

int len=strlen(str);

char *d=dest;

char *s=src[len];

while(len--!=0)

d++=s--;

printf(“%s”,dest);

}

找出错误!!

#include “string.h”

#include “stdio.h”

#include “malloc.h”

main(void)

{

char *src=“hello,world”;

char *dest=NULL;

dest=(char *)malloc(sizeof(char)*(strlen(src)+1));

int len=strlen(src);

char *d=dest;

char *s=src+len-1;

while(len--!=0)

*d++=*s--;

*d=“”;

printf(“%s”,dest);

}

篇12：C语言面试题大9

今天早上的面试题9道，比较难，向牛人请教，国内的一牛公司，坐落在北京北四环某大厦：

1、线形表a、b为两个有序升序的线形表，编写一程序，使两个有序线形表合并成一个有序升序线形表h;

答案在请化大学严锐敏《数据结构第二版》第二章例题，数据结构当中，这个叫做：两路归并排序

Linklist *unio(Linklist *p,Linklist *q){

linklist *R,*pa,*qa,*ra;

pa=p;

qa=q;

R=ra=p;

while(pa->next!=NULL&&qa->next!=NULL){

if(pa->data>qa->data){

ra->next=qa;

qa=qa->next;

}

else{

ra->next=pa;

pa=pa->next;

}

if(pa->next!=NULL)

ra->next=pa;

if(qa->next!=NULL)

ra->next==qa;

return R;

}

2、运用四色定理，为N个局域举行配色，颜色为1、2、3、4四种，另有数组adj[][N]，如adj[i][j]=1则表示i区域与j区域相邻，数组color[N]，如color[i]=1,表示i区域的颜色为1号颜色，

C语言面试题大汇总9

，

四色填充

3、用递归算法判断数组a[N]是否为一个递增数组。

递归的方法，记录当前最大的，并且判断当前的是否比这个还大，大则继续，否则返回false结束：

bool fun( int a[], int n )

{

if( n= =1 )

return true;

if( n= =2 )

return a[n-1] >= a[n-2];

return fun( a,n-1) && ( a[n-1] >= a[n-2] );

}

4、编写算法，从10亿个浮点数当中，选出其中最大的10000个。

用外部排序，在《数据结构》书上有

《计算方法导论》在找到第n大的数的算法上加工

5、编写一unix程序，防止僵尸进程的出现。

★ c语言指针

★ C语言论文