C语言软件工程师笔试题精华_软件工程师c语言笔试

2020-02-28 其他范文下载本文

C语言软件工程师笔试题精华由刀豆文库小编整理，希望给你工作、学习、生活带来方便，猜你可能喜欢“软件工程师c语言笔试”。

网络安全应具有以下五个方面的特征：

保密性：信息不泄露给非授权用户、实体或过程，或供其利用的特性。

完整性：数据未经授权不能进行改变的特性。即信息在存储或传输过程中保持不被修改、不被破坏和丢失的特性。

可用性：可被授权实体访问并按需求使用的特性。即当需要时能否存取所需的信息。例如网络环境下拒绝服务、破坏网络和有关系统的正常运行等都属于对可用性的攻击；

可控性：对信息的传播及内容具有控制能力。

可审查性：出现安全问题时提供依据与手段第一部分：基本概念及其它问答题

1、关键字static的作用是什么？

这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用： 1).在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。

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

3).在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。（本地化数据和代码范围的好处和重要性）。

2、“引用”与指针的区别是什么？

答、1)引用必须被初始化，指针不必。

2)引用初始化以后不能被改变，指针可以改变所指的对象。3)不存在指向空值的引用，但是存在指向空值的指针。

指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。

流操作符>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。

3、.h头文件中的ifndef/define/endif 的作用？答：防止该头文件被重复引用。

4、#include 与 #include “file.h”的区别？

答：前者是从Standard Library的路径寻找和引用file.h，而后者是从当前工作路径搜寻并引用file.h。

5、描述实时系统的基本特性

答：在特定时间内完成特定的任务，实时性与可靠性。

6、全局变量和局部变量在内存中是否有区别？如果有，是什么区别？答：全局变量储存在静态数据区，局部变量在堆栈中。

7、什么是平衡二叉树？

答：左右子树都是平衡二叉树且左右子树的深度差值的绝对值不大于1。

8、堆栈溢出一般是由什么原因导致的？

答：1.没有回收垃圾资源2.层次太深的递归调用

9、冒泡排序算法的时间复杂度是什么？答：O(n^2)

10、什么函数不能声明为虚函数？答：constructor11、队列和栈有什么区别？答：队列先进先出，栈后进先出

12、不能做switch()的参数类型答：switch的参数不能为实型。

13、局部变量能否和全局变量重名？答：能，局部会屏蔽全局。要用全局变量，需要使用”::”

局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内

14、如何引用一个已经定义过的全局变量？

答、可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变量，假定你将那个变量写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错。

15、全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？答、可以，在不同的C文件中以static形式来声明同名全局变量。可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错。

16、语句for(；1 ；)有什么问题？它是什么意思？答、和while(1)相同，无限循环。

17、do„„while和while„„do有什么区别？答、前一个循环一遍再判断，后一个判断以后再循环。

18、statac 全局变量、局部变量、函数与普通全局变量、局部变量、函数

答、全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。

static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件

static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值； static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

19、程序的内存分配

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

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

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

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

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

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

这是一个前辈写的，非常详细 //main.cpp int a=0;//全局初始化区 char *p1;//全局未初始化区 main(){ intb;栈

char s[]=”abc”;//栈 char *p2;//栈

char *p3=”123456″;//123456在常量区，p3在栈上。static int c=0； //全局（静态）初始化区 p1 =(char*)malloc(10);p2 =(char*)malloc(20);//分配得来得10和20字节的区域就在堆区。

strcpy(p1,”123456″);//123456放在常量区，编译器可能会将它与p3所向”123456″优化成一个地方。} 20、解释堆和栈的区别

答：堆（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”;aaaaaaaaaaa是在运行时刻赋值的； char *s2=”bbbbbbbbbbbbbbbbb”;而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读取字符，显然慢了。

21、什么是预编译,何时需要预编译? 答：预编译又称为预处理,是做些代码文本的替换工作。处理#开头的指令,比如拷贝#include包含的文件代码，#define宏定义的替换,条件编译等，就是为编译做的预备工作的阶段，主要处理#开始的预编译指令，预编译指令指示了在程序正式编译前就由编译器进行的操作，可以放在程序中的任何位置。c编译系统在对程序进行通常的编译之前，先进行预处理。

c提供的预处理功能主要有以下三种：1）宏定义 2）文件包含 3）条件编译

22、关键字const是什么含意？

答： “const意味着常数”业余者。“只读”正确的答案。const int a;a是一个常整型数 int const a;a是一个常整型数

const int *a;a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。int * const a;a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）int const * a const;a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）

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

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

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

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

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

2).一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)3).多线程应用中被几个任务共享的变量

1).一个参数既可以是const还可以是volatile吗？解释为什么。是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

2).一个指针可以是volatile 吗？解释为什么。是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。3).下面的函数有什么错误： int square(volatile int *ptr){return *ptr * *ptr;} 这段代码的有个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方，但是由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码 int square(volatile int *ptr){int a,b;a = *ptr;b = *ptr;return a * b;} 由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：

long square(volatile int *ptr){ int a;a = *ptr;return a * a;}

24、三种基本的数据模型

答：按照数据结构类型的不同，将数据模型划分为层次模型、网状模型和关系模型。

25、结构与联合有和区别？

答：(1).结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员（所有成员共用一块地址空间）, 而结构的所有成员都存在（不同成员的存放地址不同）。

(2)对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的26、描述内存分配方式以及它们的区别? 答：1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。

2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。

3）从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多

27、请说出const与#define 相比，有何优点？

答：Const作用：定义常量、修饰函数参数、修饰函数返回值三个作用。被Const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。

1）const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。

2）有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。

28、简述数组与指针的区别？

答：数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。(1)修改内容上的差别 char a[] = “hello”;a[0] = ‘X’;

char *p = “world”;// 注意p 指向常量字符串

p[0] = ‘X’;// 编译器不能发现该错误，运行时错误

(2)用运算符sizeof 可以计算出数组的容量（字节数）。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。char a[] = “hello world”;char *p = a;cout

29、分别写出BOOL,int,float,指针类型的变量a 与“零”的比较语句。答：BOOL : if(!a)or if(a)int : if(a == 0)float : const EXPRESSION EXP = 0.000001 if(a-EXP)pointer : if(a!= NULL)or if(a == NULL)30、如何判断一段程序是由C 编译程序还是由C++编译程序编译的？答：#ifdef __cplusplus cout

31、论述含参数的宏与函数的优缺点答：带参宏函数处理时间编译时程序运行时

参数类型没有参数类型问题定义实参、形参类型处理过程不分配内存分配内存程序长度变长不变

运行速度不占运行时间调用和返回占用时间

32、用两个栈实现一个队列的功能？要求给出算法和思路！答：设2个栈为A,B, 一开始均为空.入队:将新元素push入栈A;出队:(1)判断栈B是否为空；(2)如果不为空，则将栈A中所有元素依次pop出并push到栈B；(3)将栈B的栈顶元素pop出；

这样实现的队列入队和出队的平摊复杂度都还是O(1), 比上面的几种方法要好

33、嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？答：这个问题用几个解决方案。我首选的方案是： while(1){ } 一些程序员更喜欢如下方案： for(;;){ } 第三个方案是用 goto Loop:...goto Loop;应试者如给出上面的方案，这说明或者他是一个汇编语言程序员（这也许是好事）或者他是一个想进入新领域的BASIC/FORTRAN程序员。

34、位操作（Bit manipulation）

答：嵌入式系统总是要用户对变量或寄存器进行位操作。给定一个整型变量a，写两段代码，第一个设置a的bit 3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。对这个问题有三种基本的反应

1)不知道如何下手。该被面者从没做过任何嵌入式系统的工作。

2)用bit fields。Bit fields是被扔到C语言死角的东西，它保证你的代码在不同编译器之间是不可移植的，同时也保证了的你的代码是不可重用的。我最近不幸看到 Infineon为其较复杂的通信芯片写的驱动程序，它用到了bit fields因此完全对我无用，因为我的编译器用其它的方式来实现bit fields的。从道德讲：永远不要让一个非嵌入式的家伙粘实际硬件的边。

3)用 #defines 和 bit masks 操作。这是一个有极高可移植性的方法，是应该被用到的方法。最佳的解决方案如下：

#define BIT3(0x1

35、访问固定的内存位置（Acceing fixed memory locations）

答：嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。

这一问题测试你是否知道为了访问一绝对地址把一个整型数强制转换（typecast）为一指针是合法的。这一问题的实现方式随着个人风格不同而不同。典型的类似代码如下： int *ptr;ptr =(int *)0x67a9;*ptr = 0xaa66;A more obscure approach is: 一个较晦涩的方法是：

*(int * const)(0x67a9)= 0xaa55;即使你的品味更接近第二种方案，但我建议你在面试时使用第一种方案。

36、中断（Interrupts）

答：中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展—让标准C支持中断。具代表事实是，产生了一个新的关键字 __interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序(ISR)，请评论一下这段代码的。

__interrupt double compute_area(double radius){ double area = PI * radius * radius;printf(“nArea = %f”, area);return area;} 这个函数有太多的错误了，以至让人不知从何说起了：

1)ISR 不能返回一个值。如果你不懂这个，那么你不会被雇用的。

2)ISR 不能传递参数。如果你没有看到这一点，你被雇用的机会等同第一项。

3)在许多的处理器/编译器中，浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈，有些处理器/编译器就是不允许在ISR中做浮点运算。此外，ISR应该是短而有效率的，在ISR中做浮点运算是不明智的。4)与第三点一脉相承，printf()经常有重入和性能上的问题。如果你丢掉了第三和第四点，我不会太为难你的。不用说，如果你能得到后两点，那么你的被雇用前景越来越光明了。

37、动态内存分配（Dynamic memory allocation）

答：尽管不像非嵌入式计算机那么常见，嵌入式系统还是有从堆（heap）中动态分配内存的过程的。那么嵌入式系统中，动态分配内存可能发生的问题是什么？

这里，我期望应试者能提到内存碎片，碎片收集的问题，变量的持行时间等等。这个主题已经在ESP杂志中被广泛地讨论过了（主要是 P.J.Plauger, 他的解释远远超过我这里能提到的任何解释），所有回过头看一下这些杂志吧！让应试者进入一种虚假的安全感觉后，我拿出这么一个小节目：下面的代码片段的输出是什么，为什么？ char *ptr;if((ptr =(char *)malloc(0))== NULL)puts(“Got a null pointer”);else puts(“Got a valid pointer”);这是一个有趣的问题。最近在我的一个同事不经意把0值传给了函数malloc，得到了一个合法的指针之后，我才想到这个问题。这就是上面的代码，该代码的输出是“Got a valid pointer”。我用这个来开始讨论这样的一问题，看看被面试者是否想到库例程这样做是正确。得到正确的答案固然重要，但解决问题的方法和你做决定的基本原理更重要些。

38、Typedef 答：Typedef 在C语言中频繁用以声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。例如，思考一下下面的例子： #define dPS struct s * typedef struct s * tPS;以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢？（如果有的话）为什么？这是一个非常微妙的问题，任何人答对这个问题（正当的原因）是应当被恭喜的。答案是：typedef更好。思考下面的例子： dPS p1,p2;tPS p3,p4;第一个扩展为

struct s * p1, p2;上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。

39、用变量a给出下面的定义

答：a)一个整型数（An integer）

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

c)一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer）d)一个有10个整型数的数组（An array of 10 integers）

e)一个有10个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers）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 argument and returns an integer h)int(*a[10])(int);// An array of 10 pointers to functions that take an integer argument and return an integer 40、解释局部变量、全局变量和静态变量的含义。答：

41、写一个“标准”宏

答：交换两个参数值的宏定义为：.#define SWAP(a,b)(a)=(a)+(b);(b)=(a)-(b);(a)=(a)-(b);输入两个参数，输出较小的一个：#define MIN(A,B)((A)

42、A.c 和B.c两个c文件中使用了两个相同名字的static变量,编译的时候会不会有问题?这两个static变量会保存到哪里（栈还是堆或者其他的）? 答：static的全局变量，表明这个变量仅在本模块中有意义，不会影响其他模块。他们都放在数据区，但是编译器对他们的命名是不同的。

如果要使变量在其他模块也有意义的话，需要使用extern关键字。

43、一个单向链表，不知道头节点,一个指针指向其中的一个节点，问如何删除这个指针指向的节点？

答：将这个指针指向的next节点值copy到本节点，将next指向next->next,并随后删除原next指向的节点。第二部分：程序代码评价或者找错

1、下面的代码输出是什么，为什么？ void foo(void){ unsigned int a = 6;int b =-20;(a+b > 6)? puts(“> 6″): puts(“6″。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果你答错了这个问题，你也就到了得不到这份工作的边缘。

2、评价下面的代码片断： unsigned int zero = 0;unsigned int compzero = 0xFFFF;/*1′s complement of zero */

对于一个int型不是16位的处理器为说，上面的代码是不正确的。应编写如下： unsigned int compzero = ~0;这一问题真正能揭露出应试者是否懂得处理器字长的重要性。在我的经验里，好的嵌入式程序员非常准确地明白硬件的细节和它的局限，然而PC机程序往往把硬件作为一个无法避免的烦恼。

3、C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什么？ int a = 5, b = 7, c;c = a+++b;这个问题将做为这个测验的一个愉快的结尾。不管你相不相信，上面的例子是完全合乎语法的。问题是编译器如何处理它？水平不高的编译作者实际上会争论这个问题，根据最处理原则，编译器应当能处理尽可能所有合法的用法。因此，上面的代码被处理成： c = a++ + b;因此, 这段代码持行后a = 6, b = 7, c = 12。

如果你知道答案，或猜出正确答案，做得好。如果你不知道答案，我也不把这个当作问题。我发现这个问题的最大好处是这是一个关于代码编写风格，代码的可读性，代码的可修改性的好的话题。

4、设有以下说明和定义：

typedef union {long i;int k[5];char c;} DATE;struct data { int cat;DATE cow;double dog;} too;DATE max;则语句 printf(“%d”,sizeof(struct date)+sizeof(max));的执行结果是？

答、结果是：52。DATE是一个union, 变量公用空间.里面最大的变量类型是int[5], 占用20个字节.所以它的大小是20 data是一个struct, 每个变量分开占用空间.依次为int4 + DATE20 + double8 = 32.所以结果是 20 + 32 = 52.当然„在某些16位编辑器下, int可能是2字节,那么结果是 int2 + DATE10 + double8 = 205、请写出下列代码的输出内容 b=a++;#include c=++a;main()d=10*a++;{ printf(“b，c，d：%d，%d，%d”，b，c，d）;int a,b,c,d;return 0;a=10;} 答：10，12，1206、写出下列代码的输出内容 #include int inc(int a){ return(++a);} int multi(int*a,int*b,int*c){ return(*c=*a**b);} typedef int(FUNC1)(int in);typedef int(FUNC2)(int*,int*,int*);void show(FUNC2 fun,int arg1, int*arg2){ INCp=&inc;int temp =p(arg1);fun(&temp,&arg1, arg2);printf(“%dn”,*arg2);} main(){ int a;show(multi,10,&a);return 0;} 答：1107、请找出下面代码中的所以错误

说明：以下代码是把一个字符串倒序，如“abcd”倒序后变为“dcba”

1、#include”string.h”

2、main()

3、{

4、char*src=”hello,world”;

5、char* dest=NULL;

6、int len=strlen(src);

7、dest=(char*)malloc(len);

8、char* d=dest;

9、char* s=src[len];

10、while(len–!=0)

11、d++=s–;

12、printf(“%s”,dest);

13、return 0;

14、} 答：方法1： int main(){ char* src = “hello,world”;int len = strlen(src);

char* dest =(char*)malloc(len+1);//要为分配一个空间

char* d = dest;

char* s = &src[len-1];//指向最后一个字符 while(len–!= 0)*d++=*s–;

*d = 0;//尾部要加 printf(“%sn”,dest);

free(dest);// 使用完，应当释放空间，以免造成内存汇泄露 return 0;}

方法2： #include #include main(){

char str[]=”hello,world”;int len=strlen(str);char t;

for(int i=0;i {

t=str[i];

str[i]=str[len-i-1];str[len-i-1]=t;}

printf(“%s”,str);return 0;}

8、请问下面程序有什么错误? int a[60][250][1000],i,j,k;for(k=0;k

答案：把循环语句内外换一下

9、请问下面程序会出现什么情况?.#define Max_CB 500

void LmiQueryCSmd(Struct MSgCB * pmsg){

unsigned char ucCmdNum;......for(ucCmdNum=0;ucCmdNum

......;}

答案：死循环

10、以下3个有什么区别

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

const char *p； //和char const *p11、写出下面的结果 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

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

12、以下代码中的两个sizeof用法有问题吗？

void UpperCase(char str[])// 将 str 中的小写字母转换成大写字母 { for(size_t i=0;i if('a'

13、写出输出结果 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].14、请问以下代码有什么问题： 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]的赋值操作是不合法的。

15、有以下表达式：

int a=248;b=4;int const c=21;const int *d=&a;int *const e=&b;int const *f const =&a;请问下列表达式哪些会被编译器禁止？为什么？ *c=32;d=&b;*d=43;e=34;e=&a;f=0x321f;*c 这是个什么东东，禁止 *d 说了是const，禁止 e = &a 说了是const 禁止 const *f const =&a;禁止

16、交换两个变量的值，不使用第三个变量。即a=3,b=5,交换之后a=5,b=3;

有两种解法, 一种用算术算法, 一种用^(异或)a = a + b;b = ab;or a = a^b;b = a^b;a = a^b;// 只能对int,char..or a ^= b ^= a;

17、下面的程序会出现什么结果.#include #include void getmemory(char *p){p=(char *)malloc(100);strcpy(p,”hello world”);} int main(){char *str=NULL;getmemory(str);printf(“%s/n”,str);free(str);return 0;} 程序崩溃，getmemory中的malloc 不能返回动态内存，free（）对str操作很危险

18、下面的语句会出现什么结果？ char szstr[10];strcpy(szstr,”0123456789″);

答案：长度不一样，会造成非法的OS，应该改为char szstr[11]；

19、(void *)ptr 和(*(void**))ptr的结果是否相同？答：其中ptr为同一个指针，(void *)ptr 和(*(void**))ptr值是相同的 20、问函数既然不会被其它函数调用，为什么要返回1？int main(){ int x=3;printf(“%d”,x);return 1;} 答：mian中，c标准认为0表示成功，非0表示错误。具体的值是某中具体出错信息

21、对绝对地址0×100000赋值且想让程序跳转到绝对地址是0×100000去执行

(unsigned int*)0×100000 = 1234;首先要将0×100000强制转换成函数指针,即:(void(*)())0×100000 然后再调用它: *((void(*)())0×100000)();用typedef可以看得更直观些: typedef void(*)()voidFuncPtr;*((voidFuncPtr)0×100000)();

22、输出多少？并分析过程 unsigned short A = 10;printf(“~A = %un”, ~A);char c=128;

printf(“c=%dn”,c);

第一题，～A ＝0xfffffff5,int值为－11，但输出的是uint。所以输出4294967285

第二题，c＝0×10,输出的是int，最高位为1，是负数，所以它的值就是0×00的补码就是128，所以输出－128。这两道题都是在考察二进制向int或uint转换时的最高位处理。

23、分析下面的程序：

void GetMemory(char **p,int num){

*p=(char *)malloc(num);}

int main(){

char *str=NULL;

GetMemory(&str,100);strcpy(str,”hello”);free(str);if(str!=NULL){

strcpy(str,”world”);}

printf(“n str is %s”,str);getchar();}

问输出结果是什么？希望大家能说说原因，先谢谢了输出str is world。

free 只是释放的str指向的内存空间,它本身的值还是存在的.所以free之后，有一个好的习惯就是将str=NULL.此时str指向空间的内存已被回收,如果输出语句之前还存在分配空间的操作的话,这段存储空间是可能被重新分配给其他变量的,尽管这段程序确实是存在大大的问题（上面各位已经说得很清楚了），但是通常会打印出world来。

这是因为，进程中的内存管理一般不是由操作系统完成的，而是由库函数自己完成的。

当你malloc一块内存的时候，管理库向操作系统申请一块空间（可能会比你申请的大一些），然后在这块空间中记录一些管理信息（一般是在你申请的内存前面一点），并将可用内存的地址返回。但是释放内存的时候，管理库通常都不会将内存还给操作系统，因此你是可以继续访问这块地址的，只不过。。。。楼上都说过了，最好别这么干。

sizeof()和初不初始化，没有关系； strlen()和初始化有关。

char(*str)[20];/*str是一个数组指针，即指向数组的指针．*/

char *str[20];/*str是一个指针数组，其元素为指针型数据．*/

25、long a=0×801010;a+5=? 答：0×801010用二进制表示为：“1000 0000 0001 0000 0001 0000”，十进制的值为8392720，再加上5就是839272527、下面的函数实现在一个数上加一个数，有什么错误？请改正。

int add_n(int n){ static int i = 100;i += n;return i;} 当你第二次调用时得不到正确的结果，难道你写个函数就是为了调用一次？问题就出在 static上

28、给出下面程序的答案 typedef struct AA { int b1:5;int b2:2;}AA;void main(){ AA aa;char cc[100];strcpy(cc,”0123456789abcdefghijklmnopqrstuvwxyz”);

memcpy(&aa,cc,sizeof(AA));cout

首先sizeof(AA)的大小为4,b1和b2分别占5bit和2bit.经过strcpy和memcpy后,aa的4个字节所存放的值是: 0,1,2,3的ASC码，即00110000,00110001,00110010,00110011 所以，最后一步：显示的是这４个字节的前５位，和之后的２位

分别为：10000,和01 因为int是有正负之分

所以：答案是-16和１

29、求函数返回值，输入x=9999;int func（x）{ int countx = 0;while(x){ countx ++;x = x&(x-1);}

return countx;}

结果？这是统计9999的二进制数值中有多少个1的函数，且有9999＝9×1024＋512＋256＋159×1024中含1的个数为2；512中含有1的个数为1；256中含1的个数为1；15中含1的个数为4；故共有1的个数为8，结果为8。

1000k);return 0;}

#include void main(){

unsigned long int a,i=1;scanf(“%d”,&a);if(a%2==0){

for(i=1;i printf(“%d”,a,a-i);} else

for(i=1;i

printf(“ %d, %d”,i,a-i);}

3、递规反向输出字符串的例子,可谓是反序的经典例程.void inverse(char *p){

if(*p = = '')return;

inverse(p+1);printf(“%c”, *p);}

int main(int argc, char *argv[]){

inverse(“abc”);

return 0;} 对1的另一种做法： #include void test(FILE *fread, FILE *fwrite){ char buf[1024] = {0};if(!fgets(buf, sizeof(buf), fread))return;test(fread, fwrite);fputs(buf, fwrite);} int main(int argc, char *argv[]){ FILE *fr = NULL;FILE *fw = NULL;fr = fopen(“data”, “rb”);fw = fopen(“dataout”, “wb”);test(fr, fw);fclose(fr);fclose(fw);return 0;}

4、写一段程序，找出数组中第k大小的数，输出数所在的位置。例如{2，4，3，4，7}中，第一大的数是7，位置在4。第二大、第三大的数都是4，位置在1、3随便输出哪一个均可。函数接口为：int find_orderk(const int* narry,const int n,const int k)要求算法复杂度不能是O(n^2）谢谢！

可以先用快速排序进行排序，其中用另外一个进行地址查找

代码如下，在VC++6.0运行通过。给分吧^-^ //快速排序 #include usingnamespacestd;intPartition(int*L,intlow,int high){ inttemp = L[low];intpt = L[low];while(low = pt)–high;L[low] = L[high];while(low

}

L[low] = temp;returnlow;}

voidQSort(int*L,intlow,int high){

if(low

intpl = Partition(L,low,high);QSort(L,low,pl1] = t;sum++;cin >> t;}

sum-= 1;

QSort(narry,1,sum);

for(int i = 1;i

cout > k;intaa = 1;intkk = 0;for(;;){

if(aa == k)break;

if(narry[kk]!= narry[kk + 1]){

aa += 1;kk++;} }

cout

5、两路归并排序

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;}

6、用递归算法判断数组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]);}

7、单连表的建立，把’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);

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

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;}

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

10、不用库函数,用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)u +1;//MainStr指向当前起始位，u指向 } MainStr ++;}

return-1;}

17、已知一个单向链表的头，请写出删除其某一个结点的算法，要求，先找到此结点，然后删除。

slnodetype *Delete(slnodetype *Head,int key){}中if(Head->number==key){

Head=Pointer->next;free(Pointer);break;}

Back = Pointer;

Pointer=Pointer->next;if(Pointer->number==key){

Back->next=Pointer->next;free(Pointer);break;}

void delete(Node* p){

if(Head = Node)while(p)}

18、有1,2,„.一直到n的无序数组,求排序算法,并且要求时间复杂度为O(n),空间复杂度O(1),使用交换,而且一次只能交换两个数.（华为）#include int main(){

int a[] = {10,6,9,5,2,8,4,7,1,3};int len = sizeof(a)/ sizeof(int);int temp;

for(int i = 0;i

temp = a[a[i]1] = a[i];a[i] = temp;

if(a[i] == i + 1)i++;}

for(int j = 0;j return 0;}

19、写出程序把一个链表中的接点顺序倒排 typedef struct linknode {

int data;struct linknode *next;}node;//将一个链表逆置

node *reverse(node *head){ node *p,*q,*r;p=head;q=p->next;while(q!=NULL){ r=q->next;q->next=p;p=q;q=r;} head->next=NULL;head=p;return head;} 20、写出程序删除链表中的所有接点 void del_all(node *head){ node *p;while(head!=NULL){ p=head->next;free(head);head=p;} cout

21、两个字符串，s,t;把t字符串插入到s字符串中，s字符串有足够的空间存放t字符串

void insert(char *s, char *t, int i){ char *q = t;char *p =s;if(q == NULL)return;while(*p!=''){ p++;} while(*q!=0){ *p=*q;p++;q++;} *p = '';}

23、公司考试这种题目主要考你编写的代码是否考虑到各种情况，是否安全（不会溢出）各种情况包括：

１、参数是指针，检查指针是否有效

２、检查复制的源目标和目的地是否为同一个，若为同一个，则直接跳出３、读写权限检查

４、安全检查，是否会溢出

memcpy拷贝一块内存，内存的大小你告诉它 strcpy是字符串拷贝，遇到’′结束 /* memcpy ─── 拷贝不重叠的内存块 */

void memcpy(void* pvTo, void* pvFrom, size_t size){

void* pbTo =(byte*)pvTo;void* pbFrom =(byte*)pvFrom;

ASSERT(pvTo!= NULL && pvFrom!= NULL);//检查输入指针的有效性

ASSERT(pbTo>=pbFrom+size ||

pbFrom>=pbTo+size);//检查两个指针指向的内存是否重叠

while(size–>0)

*pbTo++ == *pbFrom++;return(pvTo);}

24、两个字符串，s,t;把t字符串插入到s字符串中，s字符串有足够的空间存放t字符串

void insert(char *s, char *t, int i){

memcpy(&s[strlen(t)+i],&s[i],strlen(s)-i);memcpy(&s[i],t,strlen(t));s[strlen(s)+strlen(t)]=’′;}

25、编写一个 C 函数，该函数在一个字符串中找到可能的最长的子字符串，且该字符串是由同一字符组成的。

char * search(char *cpSource, char ch){

char *cpTemp=NULL, *cpDest=NULL;int iTemp, iCount=0;while(*cpSource){

if(*cpSource == ch){

iTemp = 0;

cpTemp = cpSource;while(*cpSource == ch)++iTemp, ++cpSource;if(iTemp > iCount)

iCount = iTemp, cpDest = cpTemp;if(!*cpSource)break;} ++cpSource;} return cpDest;}

26、请编写一个 C 函数，该函数在给定的内存区域搜索给定的字符，并返回该字符所在位置索引值。int search(char *cpSource, int n, char ch){ int i;for(i=0;i return i;}

27、给定字符串A和B,输出A和B中的最大公共子串。比如A=“aocdfe” B=“pmcdfa” 则输出“cdf” */ //Author: azhen #include #include #include char *commanstring(char shortstring[], char longstring[]){ int i, j;char *substring=malloc(256);if(strstr(longstring, shortstring)!=NULL)//如果„„，那么返回shortstring return shortstring;for(i=strlen(shortstring)-1;i>0;i–)//否则，开始循环计算 { for(j=0;jstrlen(str2))//将短的字符串放前面 comman=commanstring(str2, str1);else

comman=commanstring(str1, str2);

printf(“the longest comman string is: %sn”, comman);}

28、写一个函数比较两个字符串str1和str2的大小，若相等返回0，若str1大于

str2返回1，若str1小于str2返回－1

int strcmp(const char * src,const char * dst){

int ret = 0;while(!(ret = *(unsigned char *)src – *(unsigned char *)dst)&& *dst){

++src;++dst;}

if(ret

else if(ret > 0)ret = 1;

return(ret);}

29、求1000！的未尾有几个0（用素数相乘的方法来做，如72=2*2*2*3*3）;

求出1->1000里,能被5整除的数的个数n1,能被25整除的数的个数n2,能被125整除的数的个数n3, 能被625整除的数的个数n4.1000!末尾的零的个数=n1+n2+n3+n4;#include

#define NUM 1000 int find5(int num){ int ret=0;

while(num%5==0){ num/=5;ret++;}

return ret;}

int main(){ int result=0;int i;

for(i=5;i

result+=find5(i);}

printf(“ the total zero number is %dn”,result);return 0;}

30、有双向循环链表结点定义为： 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;} } }

31、编程实现：找出两个字符串中最大公共子字符串,如”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

if(count > maxlen){

maxlen = count;*r1 = s1 + i;*r2 = s2 + j;} } } }

32、编程实现：把十进制数(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 >28);temp[i] = temp[i] >= 0 ? temp[i] : temp[i] + 16;temp[i] = temp[i]

33、输入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 解答：#define N 15 int s[N][N];void main(){ int k = 0, i = 0, j = 0;int a = 1;for(;k k-1)s[i][j--] = a++;i–;j++;while(i > k)s[i--][j] = a++;i++;j++;} for(i = 0;i

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

if(n == 1){ //矩阵大小为1时 matrix[x][y] = start;return;}

for(i = x;i

for(j = y;j

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

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

34、斐波拉契数列递归实现的方法如下： 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

现在大多数系统都是将低字位放在前面，而结构体中位域的申明一般是先声明高位。100 的二进制是 001 100 100 低位在前高位在后 001----s3 100----s2 100----s1 所以结果应该是 1 如果先申明的在低位则： 001----s1 100----s2 100----s3 结果是 41、原题跟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模式，这样输出结果可能为435、判断一个字符串是不是回文 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;}

36、Josephu 问题为：设编号为1，2，„ n的n个人围坐一圈，约定编号为k（1

int Josephu(int n, int m){

int flag, i, j = 0;

int *arr =(int *)malloc(n * sizeof(int));for(i = 0;i

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号n”, i, j);}

free(arr);return j;}

int main(){

int n, m;

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

printf(“最后胜利的是%d号！n”, Josephu(n, m));system(“pause”);return 0;}

链表实现： #include #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 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 next;} tail->next = head->next;printf(“第%4d个出局的人是：%4d号n”, 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号！n”, Josephu(n, m));system(“pause”);return 0;} 第四部分：附加部分

1、位域：

有些信息在存储时，并不需要占用一个完整的字节，而只需占几个或一个二进制位。例如在存放一个开关量时，只有0和1 两种状态，用一位二进位即可。为了节省存储空间，并使处理简便，Ｃ语言又提供了一种数据结构，称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几个不同的区域，并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。这样就可以把几个不同的对象用一个字节的二进制位域来表示。

一、位域的定义和位域变量的说明位域定义与结构定义相仿，其形式为： struct 位域结构名 { 位域列表 };

其中位域列表的形式为：类型说明符位域名：位域长度例如： struct bs {

int a:8;int b:2;int c:6;};

位域变量的说明与结构变量说明的方式相同。可采用先定义后说明，同时定义说明或者直接说明这三种方式。例如： struct bs {

int a:8;int b:2;int c:6;}data;

说明data为bs变量，共占两个字节。其中位域a占8位，位域b占2位，位域c占6位。对于位域的定义尚有以下几点说明：

1.一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如： struct bs {

unsigned a:4

unsigned :0 /*空域*/

unsigned b:4 /*从下一单元开始存放*/ unsigned c:4 }

在这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位。

2.由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位。3.位域可以无位域名，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如： struct k {

int a:1

int :2 /*该2位不能使用*/

int b:3 int c:2 };从以上分析可以看出，位域在本质上就是一种结构类型，不过其成员是按二进位分配的。

二、位域的使用位域的使用和结构成员的使用相同，其一般形式为：位域变量名•位域名位域允许用各种格式输出。main(){ struct bs { unsigned a:1;unsigned b:3;unsigned c:4;} bit,*pbit;bit.a=1;bit.b=7;bit.c=15;pri 改错： #include int main(void){ int **p;int arr[100];p = &arr;return 0;} 解答：搞错了,是指针类型不同, int **p;//二级指针

&arr;//得到的是指向第一维为100的数组的指针 #include int main(void){ int **p, *q;int arr[100];q = arr;p = &q;return 0;}

一、请填写BOOL , float, 指针变量与“零值”比较的 if 语句。（10分）

请写出 BOOL flag 与“零值”比较的 if 语句。（3分）

标准答案： if(flag)if(!flag)如下写法均属不良风格，不得分。if(flag == TRUE)if(flag == 1)if(flag == FALSE)if(flag == 0)请写出 float x 与“零值”比较的 if 语句。（4分）标准答案示例：

const float EPSINON = 0.00001;

if((x >= – EPSINON)&&(x

不可将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“

请写出 char *p 与“零值”比较的 if 语句。（3分）标准答案： if(p == NULL)

if(p!= NULL)如下写法均属不良风格，不得分。if(p == 0)if(p!= 0)if(p)if(!)

二、以下为Windows NT下的32位C++程序，请计算sizeof的值（10分）

char str[] = “Hello”;char *p = str;int n = 10;请计算

sizeof(str)= 6（2分）sizeof(p)= 4（2分）

sizeof(n)= 4（2分）void Func(char str[100]){请计算

sizeof(str)= 4（2分）}

void *p = malloc(100);请计算

sizeof(p)= 4（2分）

三、简答题（25分）

1、头文件中的 ifndef/define/endif 干什么用？（5分）

答：防止该头文件被重复引用。

2、#include 和 #include “filename.h” 有什么区别？（5分）

答：对于#include，编译器从标准库路径开始搜索 filename.h

对于#include “filename.h”，编译器从用户的工作路径开始搜索 filename.h3、const 有什么用途？（请至少说明两种）（5分）答：（1）可以定义 const 常量

（2）const可以修饰函数的参数、返回值，甚至函数的定义体。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。

4、在C++ 程序中调用被 C编译器编译后的函数，为什么要加 extern “C”？（5分）

答：C++语言支持函数重载，C语言不支持函数重载。函数被C++编译后在库中的名字与C语言的不同。假设某

个函数的原型为： void foo(int x, int y);该函数被C编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。

C++提供了C连接交换指定符号extern“C”来解决名字匹配问题。

5、请简述以下两个for循环的优缺点（5分）for(i=0;i {if(condition)DoSomething();else DoOtherthing();} if(condition){for(i=0;i DoSomething();} else {for(i=0;i DoOtherthing();} 优点：程序简洁

缺点：多执行了N-1次逻辑判断，并且打断了循环“流水线”作业，使得编译器不能对循环进行优化处理，降低了效率。优点：循环的效率高缺点：程序不简洁

四、有关内存的思考题（每小题5分，共20分）void GetMemory(char *p){p =(char *)malloc(100);} void Test(void){char *str = NULL;GetMemory(str);strcpy(str, “hello world”);printf(str);} 请问运行Test函数会有什么样的结果？答：程序崩溃。因为GetMemory并不能传递动态内存，Test函数中的 str一直都是 NULL。

strcpy(str, “hello world”);将使程序崩溃。char *GetMemory(void){ char p[] = “hello world”;return p;} void Test(void){ char *str = NULL;str = GetMemory();printf(str);}

请问运行Test函数会有什么样的结果？答：可能是乱码。

因为GetMemory返回的是指向“栈内存”的指针，该指针的地址不是 NULL，但其原现的内容已经被清除，新内容不可知。

void GetMemory2(char **p, int num){

*p =(char *)malloc(num);}

void Test(void){

char *str = NULL;GetMemory(&str, 100);strcpy(str, “hello”);printf(str);}

请问运行Test函数会有什么样的结果？答：（1）能够输出hello（2）内存泄漏 void Test(void){

char *str =(char *)malloc(100);strcpy(str, “hello”);free(str);

if(str!= NULL){

strcpy(str, “world”);printf(str);} }

请问运行Test函数会有什么样的结果？答：篡改动态内存区的内容，后果难以预料，非常危险。因为free(str);之后，str成为野指针，if(str!= NULL)语句不起作用。

五、编写strcpy函数（10分）已知strcpy函数的原型是char *strcpy(char *strDest, const char *strSrc);

其中strDest是目的字符串，strSrc是源字符串。（1）不调用C++/C的字符串库函数，请编写函数 strcpy char *strcpy(char *strDest, const char *strSrc);{aert((strDest!=NULL)&&(strSrc!=NULL));// 2分

char *addre = strDest;// 2分

while((*strDest++ = * strSrc++)!= ‘’)// 2分 NULL;

return addre;// 2分 }

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;}（2）strcpy能把strSrc的内容复制到strDest，为什么还要char * 类型的返回值？答：为了实现链式表达式。// 2分

例如 int length = strlen(strcpy(strDest, “hello world”));错误的做法：

[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字符串的末尾没有正确地加上’′。

六、编写类String的构造函数、析构函数和赋值函数（25分）

已知类String的原型为： cla String {public:

String(const char *str = NULL);// 普通构造函数 String(const String &other);// 拷贝构造函数 ~ String(void);// 析构函数

String & operate =(const String &other);// 赋值函数 private:

char *m_data;// 用于保存字符串 };

请编写String的上述4个函数。标准答案：

// String的析构函数

String::~String(void)// 3分 {delete [] m_data;

// 由于m_data是内部数据类型，也可以写成 delete m_data;}

// String的普通构造函数