命中率高C阶段面试题

1、1.const意味着”只读"，下面的声明都是什么意思？ const int a; int const a; const int *a; int * const a; int const * a const; 前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。 结论：·关键字const的作用是为给读你

2、代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果 你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清 理的。） · 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。 · 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。 （1）欲阻止一个变量被改变，可以使用 const 关键字。在定义该 const 变量时，通常需要对它进行初 始化，因为以后就没

3、有机会再去改变它了；（2）对指针来说，可以指定指针本身为 const，也可以指定指针所指的数据为 const，或二者同时指 定为 const； （3）在一个函数声明中，const 可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值； （4）对于类的成员函数，若指定其为 const 类型，则表明其是一个常函数，不能修改类的成员变量； （5）对于类的成员函数，有时候必须指定其返回值为 const 类型，以使得其返回值不为“左值”。 2.关键字volatile有什么含意?并给出三个不同的例子。一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的

4、值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子： （1）并行设备的硬件寄存器（如：状态寄存器） （2）一个中断服务子程序中会访问到的非自动变量(Non-automatic variables) （3）多线程应用中被几个任务共享的变量 3.一个参数既可以是const还可以是volatile吗？解释为什么。 一个指针可以是volatile 吗？解释为什么。 答案： （1）是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。 （

5、2） 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。 4.static关键字有什么作用？ （1）函数体内 static 变量的作用范围为该函数体，不同于 auto 变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值； （2）在模块内的 static 全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问； （3）在模块内的 static 函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明 它的模块内； （4）在类中的 static 成员变量属于整个类所拥有，对类的所有对象只有一份拷贝； （5）在类中的 stati

6、c 成员函数属于整个类所拥有，这个函数不接收 this 指针，因而只能访问类的static 成员变量。 5. extern 在"C"中有什么作用： （1）被 extern "C"限定的函数或变量是 extern 类型的； extern是 C/C+语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。 （2）被 extern "C"修饰的变量和函数是按照 C 语言方式编译和连接的； extern "C"的惯用法 （1）在 C+中引用 C 语言中的函数和

7、变量，在包含 C 语言头文件（假设为 cExample.h）时，需进 行下列处理： extern "C" #include "cExample.h" 而在 C语言的头文件中，对其外部函数只能指定为 extern 类型，C语言中不支持 extern "C"声明， 在.c 文件中包含了 extern "C"时会出现编译语法错误。 （2）在 C 中引用 C+语言中的函数和变量时，C+的头文件需添加 extern "C"，但是在 C 语言中不 能直接引用声明了 extern "C"的

8、该头文件，应该仅将 C 文件中将 C+中定义的extern "C"函数声明为 extern 类型。 6. 堆和栈的区别?管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制;对于堆来说，释放工作由程序员控制，容易产生memory leak。申请大小：栈：栈是向低地址扩展的数据结构，是一块连续的内存的区域堆：是向高地址扩展的数据结构，是不连续的内存区域。分配方式：堆都是动态分配的 ，动态分配由alloca函数进行分配栈的动态分配由编译器进行释放，无需我们手工实现7.以下函数输出结果是 main() int a5=1,2,3,4,5;int *ptr=(int *)(&a

9、mp;a+1);printf("%d,%d",*(a+1),*(ptr-1);答：2,5 *(a+1)就是a1，*(ptr-1)就是a4,执行结果是2，5&a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小(本例是5个int)int *ptr=(int *)(&a+1);则ptr实际是&(a5),也就是a+5原因如下：&a是数组指针，其类型为 int (*)5;而指针加1要根据指针类型加上一定的值，不同类型的指针+1之后增加的大小不同。a是长度为5的int数组指针，所以要加 5*sizeof(int)，所以ptr实际是

10、a5，但是prt与(&a+1)类型是不一样的(这点很重要)，所以prt-1只会减去sizeof(int*)a,&a的地址是一样的，但意思不一样a是数组首地址，也就是a0的地址，&a是对象(数组)首地址，a+1是数组下一元素的地址，即a1,&a+1是下一个对象的地址，即a5.8.链表和数组的区别在哪里?二者都属于一种数据结构从逻辑结构来看1.数组必须事先定义固定的长度(元素个数)，不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数;当数据减少时，造成内存浪费;数组可以根据下标直接存取。2.链表动态地进行存储分配，可以适应数据动态地增减的情况，且

11、可以方便地插入、删除数据项。(数组中插入、删除数据项时，需要移动其它数据项，非常繁琐)链表必须根据next指针找到下一个元素从内存存储来看1. (静态)数组从栈中分配空间, 对于程序员方便快速,但是自由度小2. 链表从堆中分配空间, 自由度大但是申请管理比较麻烦从上面的比较可以看出，如果需要快速访问数据，很少或不插入和删除元素，就应该用数组;相反， 如果需要经常插入和删除元素就需要用链表数据结构了。9.结构体struct strA int a; float b; char c; expA;printf("%ld",sizeof(expA); 输出结果为 12 ?该问题涉及编

12、译器的“内存对齐”问题：现代计算机中内存空间都是按照byte(字节)划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定变量的时候经常在特定的内存地址访问，这就需要各类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。对齐的作用和原因：各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台的要求对数据存放进行对齐，会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始，如果一个int型(假设为32位)如果存放在偶地址开始的地方

13、，那么一个读周期就可以读出，而如果存放在奇地址开始的地方，就可能会需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该int数据。显然在读取效率上下降很多。这也是空间和时间的博弈。通常，我们写程序的时候，不需要考虑对齐问题。编译器会替我们选择适合目标平台的对齐策略。当然，我们也可以通知给编译器传递预编译指令而改变对指定数据的对齐方法。但是，正因为我们一般不需要关心这个问题，所以因为编辑器对数据存放做了对齐，而我们不了解的话，常常会对一些问题感到迷惑。最常见的就是struct数据结构的sizeof结果，出乎意料。对于结构体来说，按成员中所占字节最大的是float类型，占用4个字节，一共

14、有3个成员，所以总的占用字节为：4* 3 = 12.10.为什么标准头文件都有类似以下的结构？ #ifndef _INCvxWorksh #define _INCvxWorksh #ifdef _cplusplus extern "C" #endif #ifdef _cplusplus #endif #endif 显然，头文件中的编译宏“#ifndef _INCvxWorksh、#define _INCvxWorksh、#endif” 的作用是防止该头文件被重复引用。 11.sprintf,strcpy,memcpy使用上有什么要注意的地方？ 答：strcpy是一个字符串拷

15、贝的函数，它的函数原型为strcpy(char *dst, const char *src);将src开始的一段字符串拷贝到dst开始的内存中去，结束的标志符号为''，由于拷贝的长度不是由我们自己控制的，所以这个字符串拷贝很容易出错。 具备字符串拷贝功能的函数有memcpy，这是一个内存拷贝函数，它的函数原型为memcpy(char *dst,const char* src, unsigned int len);将长度为len的一段内存，从src拷贝到dst中去，这个函数的长度可控。但是会有内存叠加的问题。 sprintf是格式化函数。将一段数据通过特定的格式，格式化到一个字符

16、串缓冲区中去。sprintf格式化的函数的长度不可控，有可能格式化后的字符串会超出缓冲区的大小，造成溢出。 12.用预处理指令#define声明一个常数，用以表明1年中有多少秒（忽略闰年问题） #define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL 13.下面是笔试常考题，下面表示代码的意思 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 a10; /一个有10个指针的数

17、组，该指针是指向一个整型数的。 e) int *a10; /一个有10个指针的数组，该指针是指向一个整型数的。 f) int (*a)10; /一个指向有10个整型数数组的指针 g) int (*a)(int); /一个指向函数的指针，该函数有一个整型参数并返回一个整型数。 h) int (*a10)(int); /一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数。 14. 以下为Windows NT下的32位C+程序，请计算sizeof的值 void Func ( char str100 ) sizeof( str ) = ? void *p = malloc

18、( 100 ); sizeof ( p ) = ? 这题很常见了,Func ( char str100 )函数中数组名作为函数形参时，在函数体内，数组名失去了本身的内涵，仅仅只是一个指针；在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。Windows NT 32位平台下，指针的长度（占用内存的大小）为4字节，故sizeof( str ) 、sizeof ( p ) 都为4。 15.写一个”标准"宏MIN ，这个宏输入两个参数并返回较小的一个。 #define MIN(A,B) （A） <= (B) ? (A) : (B) 这个测试是为下面的目的而设

19、的： 标识#define在宏中应用的基本知识。这是很重要的，因为直到嵌入(inline)操作符变为标准C的一部分，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比 if-then-else 更优化的代码，了解这个用法是很重要的。 懂得在宏中小心地把参数用括号括起来 .我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事？ least = MIN(*p+, b); 结果是： (*p+) <= (b) ? (*p+) : (*p+) 这个表达式会产生副

20、作用，指针p会作三次+自增操作。 .main()       int a5=1,2,3,4,5;     int *ptr=(int *)(&a+1);      printf("%d,%d",*(a+1),*(ptr-1); 答：2,5      *(a+1）就是a1，*(ptr-1)就是a4,执行结果是2，5 &a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小（本例是5个int）

21、int *ptr=(int *)(&a+1); 则ptr实际是&(a5),也就是a+5 原因如下： &a是数组指针，其类型为 int (*)5; 而指针加1要根据指针类型加上一定的值，不同类型的指针+1之后增加的大小不同。 a是长度为5的int数组指针，所以要加 5*sizeof(int) 所以ptr实际是a5 但是prt与(&a+1)类型是不一样的(这点很重要) 所以prt-1只会减去sizeof(int*) a,&a的地址是一样的，但意思不一样     a是数组首地址，也就是a0的地址，&a是对象（数组）首地址，

22、 a+1是数组下一元素的地址，即a1,&a+1是下一个对象的地址，即a5. 16.以下为Windows NT下的32位C+程序，请计算sizeof的值 void Func ( char str100 )      sizeof( str ) = ?    void *p = malloc( 100 ); sizeof ( p ) = ? 前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指

23、针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。 结论： 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果 你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清 理的。）  通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。  ; 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码

24、修改。简而言之，这样可以减少bug的出现。     （1）欲阻止一个变量被改变，可以使用 const 关键字。在定义该 const 变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了； （2）对指针来说，可以指定指针本身为 const，也可以指定指针所指的数据为 const，或二者同时指定为 const； （3）在一个函数声明中，const 可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值； （4）对于类的成员函数，若指定其为 const 类型，则表明其是一个常函数，不能修改类的成员变量； （5）对于类的成员函数，有时候必须指定其返回值为 c

25、onst 类型，以使得其返回值不为“左值”。 关键字volatile有什么含意?并给出三个不同的例子。   一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：   ; 并行设备的硬件寄存器（如：状态寄存器）  ; 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)  ; 多线程应用中被几个任务共享的变量

26、60; 17. 一个参数既可以是const还可以是volatile吗？解释为什么。  一个指针可以是volatile 吗？解释为什么。  下面是答案：  ; 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。  ; 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。     18.extern "C"的惯用法  （1）在 C+中引用 C 语言中的函数和变量，在包含 C 语言头文件（假

27、设为 cExample.h）时，需进 行下列处理： extern "C"    #include "cExample.h"    而在 C 语言的头文件中，对其外部函数只能指定为 extern 类型，C 语言中不支持 extern "C"声明， 在.c 文件中包含了 extern "C"时会出现编译语法错误。 （2）在 C 中引用 C+语言中的函数和变量时，C+的头文件需添加 extern "C"，但是在 C 语言中不能直接引用声明了 extern &qu

28、ot;C"的该头文件，应该仅将 C 文件中将 C+中定义的 extern "C"函数声明为 extern 类型。 19.为什么标准头文件都有类似以下的结构？     #ifndef _INCvxWorksh     #define _INCvxWorksh     #ifdef _cplusplus     extern "C"      #endif     /*.

29、*/     #ifdef _cplusplus          #endif     #endif /* _INCvxWorksh */  显然，头文件中的编译宏“#ifndef _INCvxWorksh、#define _INCvxWorksh、#endif” 的作用 是防止该头文件被重复引用。 20. 用变量a给出下面的定义   a) 一个整型数（An integer）   b)一个指向整型数的指针（ A pointer to

30、an integer）   c)一个指向指针的的指针，它指向的指针是指向一个整型数（ A pointer to a pointer to an intege）r   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） &#

31、160; 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 t hat take an integer argument and return an integer ）     答案是：

32、   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 a10; / An array of 10 integers   e) int *a10; / An array of 10 pointers to integers   f) int (*a)10; / A pointer t

33、o 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 (*a10)(int); / An array of 10 pointers to functions  that take an integer argument and return an integer 21.关键字 const什么含义？参考答案：1）欲阻止

34、一个变量被改变，可以使用 const 关键字。在定义该 const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；2）对指针来说，可以指定指针本身为 const，也可以指定指针所指的数据为const，或二者同时指定为const；3）在一个函数声明中，const 可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；4）对于类的成员函数，若指定其为 const类型，则表明其是一个常函数，不能修改类的成员变量；5）对于类的成员函数，有时候必须指定其返回值为 const类型，以使得其返回值不为“左值”。例如：const classA operator*(const classA

35、& a1,const classA& a2);operator*的返回结果必须是一个 const对象。如果不是，这样的变态代码也不会编译出错：22.static 关键字的作用？参考答案：1）函数体内 static 变量的作用范围为该函数体，不同于 auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值； 2）在模块内的 static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问； 3）在模块内的 static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内； 4）在类中的 static成员变量属于整个类所拥有，对类的

36、所有对象只有一份拷贝； 5）在类中的 static 成员函数属于整个类所拥有， 这个函数不接收 this指针，因而只能访问类static 成员变量。 23.extern “C”的作用?参考答案： extern  "C"的主要作用就是为了能够正确实现 C+代码调用其他 C语言代码。加上extern  "C"后，会指示编译器这部分代码按 C 语言的进行编译，而不是 C+的。由于 C+支持函数重载，因此编译器编译函数的过程中会将函数的参数类型也加到编译后的代码中，而不仅仅是函数名；而 C 语言并不支持函数重载，因此编译C 语言代码的函数时不

37、会带上函数的参数类型，一般只包括函数名。24.关键字 volatile是什么含义？并给出三个不同的例子参考答案：一个定义为 volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。 精确地说就是， 优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：1) 并行设备的硬件寄存器（如：状态寄存器）2) 一 个 中 断 服 务 子 程 序 中 会 访 问 到 的 非 自 动 变 量(Non-automaticvariables)3) 多线程应用中被几个任务共享的变量25.do-whi

38、le 和while 的区别？参考答案：1）do.while 语句的 while 语句后要加分号“； ”2）while 语句可能一次也不执行循环体，但 do.while语句至少执行一次循环体。3）对于同一个问题，既可以用 while 语句，也可以用 do.while 语句。26.new、delete、malloc、free 关系参考答案：delete 会调用对象的析构函数,和 new 对应 free 只会释放内存，new调用构造函数。malloc与free是C+/C语言的标准库函数，new/delete是C+的运算符。它们都可用于申请动态内存和释放内存。对于非内部数据类型的对象而言，光用 mal

39、oc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数， 对象在消亡之前要自动执行析构函数。 由于malloc/free是库函数而不是运算符， 不在编译器控制权限之内， 不能够把执行构造函数和析构函数的任务强加于 malloc/free。因此C+语言需要一个能完成动态内存分配和初始化工作的运算符 new，以及一个能完成清理与释放内存工作的运算符 delete。注意new/delete不是库函数。27. sprintf,strcpy,memcpy的功能,在使用上有哪些要注意的地方.参考答案：strcpy是一个字符串拷贝的函数， 它的函数原型为strcpy(char *dst,

40、constchar *src);将 src 开始的一段字符串拷贝到 dst开始的内存中去，结束的标志符号为'0'， 由于拷贝的长度不是由我们自己控制的， 所以这个字符串拷贝很容易出错。具备字符串拷贝功能的函数有 memcpy， 这是一个内存拷贝函数， 它的函数原型为 memcpy(char *dst, const char* src, unsigned int len);将长度为len的一段内存，从 src 拷贝到 dst 中去，这个函数的长度可控。但是会有内存叠加的问题。sprintf是格式化函数。将一段数据通过特定的格式，格式化到一个字符串缓冲区中去。sprintf格式化的

41、函数的长度不可控，有可能格式化后的字符串会超出缓冲区的大小，造成溢出。28.#define DOUBLE(x)x+x, i=5*DOUBLE(5); i 是多少？ 解析：答案是30本题主要考查学生对宏的基本知识的掌握，学习宏的时候，需要记住一个原则：原封不动的替换。也就是说宏只作替换，不做计算。29.写一个宏 MIN，这个宏输入两个参数并返回较小的一个解析：答案是 #define MIN(A,B) (A) <= (B)？ (A) : (B)这个测试是为下面的目的而设的：1)标识#define 在宏中应用的基本知识。这是很重要的，因为直到嵌入(inline)操作符变为标准C的部分，宏是方便

42、产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。2)三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。3)懂得在宏中小心地把参数用括号括起来4)我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事？least = MIN(*p+, b); 30.用预处理指令define声明一个常数，表示1 年中有多少秒（忽略闰年）解析：答案是 #define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL考查知识点：1) #defin

43、e 语法的基本知识 （例如： 不能以分号结束， 括号的使用， 等等）2)懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少 秒而不是计算出实际的值，是更清晰而没有代价的。3) 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。4) 如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点 31.用宏定义交换两个数解析：答案如下#define SWAP(a,b,type) type c; c = (a); (a) = (b); (b) = c; 32.分别给出 BOOL，int，float，指针变量 与

44、“零值”比较的 if 语句（假设变量名为 var） 解析：答案如下BOOL 型变量：if(!var)int 型变量： if(var=0)float 型变量：const float EPSINON = 0.00001;if (x >= - EPSINON) && (x <= EPSINON)指针变量： if(var=NULL)考查对 0 值判断的 “内功” ， BOOL 型变量的 0 判断完全可以写成if(var=0)，而 int 型变量也可以写成 if(!var)，指针变量的判断也可以写成if(!var)，上述写法虽然程序都能正确运行，但是未能清晰地表达程序的意思。

45、一般的，如果想让 if 判断一个变量的“真” 、 “假” ，应直接使用if(var)、if(!var)， 表明其为 “逻辑” 判断； 如果用 if 判断一个数值型变量(short、int、long等)，应该用if(var=0)，表明是与0进行“数值”上的比较；而判断指针则适宜用if(var=NULL)，这是一种很好的编程习惯。浮点型变量并不精确，所以不可将 float变量用“=”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。如果写成 if (x = 0.0)，则判为错，得0分。33.a)一个整型数_ b）一个指向整型数的指针_ c)一 个 指 向 指 针 的 指 针

46、， 它 指 向 的 指 针 是 指 向 一 个 整 _ d)一个有 10个整型数的数组_ e) 一个有 10 个整型数的数组，该指针是指向一个整型数的_ f)一个指向有 10个整型数数组的指针_ g)一个指向函数的指针，该函数有一个整型参数并返回一个整型数_解析：答案如下a) int a; b) int *a; c) int *a; d) int a10;e) int *a10; f) int (*a)10;g) int (*a)(int); h) int (*a10)(int)；34. 编写函数_memmove 说明如下： 实现 c 语言库函数 memmove的功能：将一块缓冲区中的数据移动

47、到应一块缓冲区中。说明：不能直接调用 memmove、memcpy    之类的库函数。 答案：void *memmove(void *dest, const void *src, size_t count)char *tmp, *s;if (dest <= src) tmp = (char *) dest;s = (char *) src;while (count-)*tmp+ = *s+;elsetmp = (char *) dest + count;s = (char *) src + count;while (count-)*-tmp = *-s;r

48、eturn dest;解析：如果目的地址小于源地址，说明目的地址最开始的部分并没有被覆盖重叠，就从把源地址的内容从前向后拷贝；如果目的地址大于源地址，说明目的地址的最后面的部分没有被覆盖重叠，所以就把源地址的内容从后往前拷贝。35.一个猴子吃桃一天吃桃子剩余数量的一半,感觉不够,再吃一个,共10天吃完，问一共吃了多少桃子，写出你的代码。解析：主要考查学生的逻辑思维能力，以及循环的使用。答案没有统一标准，参考答案如下：int day,x1,x2;day = 9; x2=1;while (day>0) x1 = (x2+1)*2; x2 = x1; day -;printf("to

49、tal = %d n”,x1);36. 数组有 1000 个元素，设为数组 a1000，存放 1-1000的数值，但是现在有一个数值重复了，只扫描一遍数组，找出那个重复的数参考答案如下：（假设为固定的int型数组，其元素为5个）int a5 =1,2,3,4,3;int b6 = 0;int num =0;for (int i = 0; i<5; i+) num = ai; /得到 ai的值bnum+;/让 a 数组中的值作为 b 数组的下标if (bnum>1) /此位置加了两次，其重复break; printf("重复的数字为： %d",num);相似题：设

50、计一个算法，要求在20个数字中（0到19）随机选取十个数字，但是这十个数字不能重复（用C语言或者OC实现）37.编写一个函数，作用是把一个char组成的字符串循环右移n个。比如原来是“abcdefghi”如果 n=2，移位后应该是“hiabcdefgh”函数头是这样的：/pStr 是指向以'0'结尾的字符串的指针/steps 是要求移动的nvoid LoopMove ( char * pStr, int steps )/请填充.解析： 这个试题主要考查面试者对标准库函数的熟练程度， 在需要的时候引用库函数可以很大程度上简化程序编写的工作量。参考答案如下：正确解答1：void L

51、oopMove ( char *pStr, int steps )int n = strlen( pStr ) - steps;char tmpMAX_LEN;strcpy ( tmp, pStr + n );strcpy ( tmp + steps, pStr);*( tmp + strlen ( pStr ) ) = '0'strcpy( pStr, tmp );正确解答2：void LoopMove ( char *pStr, int steps )int n = strlen( pStr ) - steps;char tmpMAX_LEN;memcpy( tmp, pS

52、tr + n, steps );memcpy(pStr + steps, pStr, n );memcpy(pStr, tmp, steps );38.找错题 void test1()char string10;char* str1 = "0123456789"strcpy( string, str1 );解析：字符串 str1 需要 11 个字节才能存放下（包括末尾的0 ） ，而string只有10个字节的空间，strcpy会导致数组越界；39.找错题void test2()char string10, str110;int i;for(i=0; i<10; i+)

53、str1 = 'a'strcpy( string, str1 );解析：如果面试者指出字符数组 str1 不能在数组内结束可以给 3分；如果面试者指出 strcpy(string, str1)调用使得从 str1url=内存/url起复制到string 内存起所复制的字节数具有不确定性可以给 7分，在此基础上指出库函数strcpy工作方式的给10分；40.找错题 void test3(char* str1)char string10;if( strlen( str1 ) <= 10 )strcpy( string, str1 );解析：; if(strlen(str1) <= 10)应改为 if(strlen(str1) < 10)，因为strlen的结果未统计0所占用的1个字节。综上得出的结论: 考查对基本功的掌握：(1)字符串以0结尾；(2)对数组越界把握的敏感度；(3)库函数 strcpy 的工作方式；(4)对 strlen 的掌握，它没有包括字符串末尾的0'。41.找错题 void GetMemory( char *p )p = (char