3. 内功题
试题1：分别给出BOOL，int，float，指针变量 与“零值”比较的 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)，上述写法虽然程序都能正确运行，但是未能清晰地表达程序的意思。
一般的，如果想让if判断一个变量的“真”、“假”，应直接使用if(var)、if(!var)，表明其为“逻辑”判断；如果用if判断一个数值型变 量(short、int、long等)，应该用if(var==0)，表明是与0进行“数值”上的比较；而判断指针则适宜用if(var==NULL)， 这是一种很好的编程习惯。
浮点型变量并不精确，所以不可将float变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。如果写成if (x == 0.0)，则判为错，得0分。

试题2：以下为Windows NT下的32位C++程序，请计算sizeof的值
void Func ( char str[100] )
{
　 sizeof( str ) =
}
void *p = malloc( 100 );
sizeof ( p ) =
解答：
sizeof( str ) = 4
sizeof ( p ) = 4
剖析：
Func ( char str[100] )函数中数组名作为函数形参时，在函数体内，数组名失去了本身的内涵，仅仅只是一个指针；在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。
数组名的本质如下：
(1) 数组名指代一种数据结构，这种数据结构就是数组；
例如：
char str[10];
cout << sizeof(str) << endl;
　　输出结果为10，str指代数据结构char[10]。
(2) 数组名可以转换为指向其指代实体的指针，而且是一个指针常量，不能作自增、自减等操作，不能被修改；
char str[10];
str++; //编译出错，提示str不是左值　
(3) 数组名作为函数形参时，沦为普通指针。
Windows NT 32位平台下，指针的长度（占用内存的大小）为4字节，故sizeof( str ) 、sizeof ( p ) 都为4。

试题3：写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。另外，当你写下面的代码时会发生什么事？
least = MIN(*p++, b);
解答：
#define MIN(A,B) ((A) <= (B) (A) : (B))
MIN(*p++, b)会产生宏的副作用
剖析：
这个面试题主要考查面试者对宏定义的使用，宏定义可以实现类似于函数的功能，但是它终归不是函数，而宏定义中括弧中的“参数”也不是真的参数，在宏展开的时候对“参数”进行的是一对一的替换。程序员对宏定义的使用要非常小心，特别要注意两个问题：
(1) 谨慎地将宏定义中的“参数”和整个宏用用括弧括起来。所以，严格地讲，下述解答：
#define MIN(A,B) (A) <= (B) (A) : (B)
#define MIN(A,B) (A <= B A : B ) 都应判0分；
(2) 防止宏的副作用。
　　宏定义#define MIN(A,B) ((A) <= (B) (A) : (B))对MIN(*p++, b)的作用结果是：((*p++) <= (b) (*p++) : (*p++)) 这个表达式会产生副作用，指针p会作三次++自增操作。除此之外，另一个应该判0分的解答是：#define MIN(A,B) ((A) <= (B) (A) : (B));
这个解答在宏定义的后面加“;”，显示编写者对宏的概念模糊不清，只能被无情地判0分并被面试官淘汰。

宏的一些副作用
1、优先级问题

1) 传入变量优先级

#define MULTI(a,b) a * b

MULTI(1+2,3) => 1 + 2 * 3 其实是想要(1 + 2) * 3

2) 作为值返回时，类似1）

#define ADD(a,b) (a) + (b)

int c = ADD(a,b) * 3; => (a) + (b) * 3 其实是想要(a + b) * 3

所以，一般的规则是：宏里面参数全部用括号括起来；如果作为值返回，整个表达式也用括号括起来。

所以，上面最好这么写：

#define MULTI(a,b) ((a) * (b))

#define ADD(a,b) ((a) + (b))

2、实际使用参数和宏内部变量同名

#define HASH(str,sz,rst) do{unsigned int n = 0; n = xxx; rst = n % sz;}while(0)

这是一个hash的宏实现，其中定义了一个临时变量n，根据str计算n，然后对sz求模并把返回值赋给传进来的rst.

这么调用：

int n;

HASH(“hello”,7,n);

不会达到改变n的效果，因为实际使用参数n和宏内部的变量n同名。宏扩展中最后一条语句是：n = n % sz;因为宏内部n有更小作 用域，实际赋值的是宏内部的那个临时变量n。外面调用的n不会有任何改变。

这个副作用有些隐蔽，一般的规则是：宏内部变量使用一种不同风格的命名方式。

比如：

#define HASH(str,sz,rst) do{unsigned int __n = 0; __n = …

3、++,–

#define MAX(a,b) ((a) > (b) (a) : (b))

int a = 3,b = 2;

int c = MAX(a++,b);

执行看看，不但a的值不是和想要的一致，返回值c也会让你大吃一惊，哈哈。(a = 5,c = 4)

在宏内部一个变量”执行”多少次，它就自增或自减了多少次。

所以一般使用宏最好不要传入自增自减。如果你一定要在宏里消除这个副作用，可以这样：

#define MAX(a,b) ({int __x = (a), __y = (b);(__x > __y) __x : __y;})

也就是：保证传入宏的参数在内部只使用一次。(注意：传入a++或++a都能得到各自正确的效果)

这里的内部变量__x,__y是不需要用括号包起来的，原因可以自己想想。

另外对宏中括号的使用补充说明两点：

因为宏中定义了临时变量，所以要用{}括起来；

因为要返回值，所以外面还要用()括起来({}不返回值)；

另外，这里还有一个问题：实际中a,b不一定是int的，这个宏中的临时变量声明为int，不通用。

改进：

#define MAX(a,b,type) ({type __x = (a), __y = (b);(__x > __y) __x : __y;})

使用：

MAX(1,2,int); MAX(1.1,1.2,double);

是不是感觉怪怪的，有点c++的感觉～～ 这样的使用太复杂了，而且也会给代码的阅读带来难度。

我觉得好的态度是多了解些宏的可能的副作用，在实际编码中遵守第1、2条规则，不要往宏中传入自增自减的东西，就够了。不要把过多的复杂度全扔给宏，”通用”也不能盲目，因为毕竟：yy是没有极限的。

试题4：为什么标准头文件都有类似以下的结构？
Code
#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus
extern “C” {
#endif
/**/
#ifdef __cplusplus
}
#endif
#endif /* __INCvxWorksh */