或许在你的意料之外(一)

1.  下面代码的输出是YES or NO

char  c;

c  = 0xF0;

if (c == 0xF0)

    printf("YES\n");

else

    printf("NO\n");

 

解析：（以32位系统为例）

首先， 编译器将0xF0视为int的， c 与0xF0比较的时候， c会作类型提升，char->int,

提升后的结果是0xFFFFFFF0 还是 0x000000F0呢？

你可能会想当然是0xFFFFFFF0, 因为char是无符号字符型？

其实不然，C标准根本就没有规定char是signed还是unsigned了，

这是由编译器自己定义的。 VC是signed的， gcc有的是signed有的是unsigned的。

 

如果一定要在gcc中char为signed char， 请指定如下flag: -fsigned-char

 

所以，一定要注意：

如果代码需要多平台移植，一定不要用 char！

可以考虑如下定义：typedef signed char S8;

                                   typedef unsigned char U8;

另外， short， int,  long是没有char这个问题的， 它们就是signed的。

 

2.  如下语句的输出是什么？

  int x = -25;
  unsigned int y = 10;

  if (x+y > 0)
     printf("x+y>0\n");
  else
     printf("x+y<=0\n");

 

解析：答案是x+y>0

还是类型提升的问题， int 跟unsigned int混合类型计算时，

int会先转换成unsigned int, -25转换成无符号就是4294967271，

结果会大的没边。

 

所以， 慎用混合类型运算！ 

 

3.  循环多少次以后退出。

  float x = 0.0;
  float delta = 0.25;

  while (1) {
      x += delta;
      if (x == 16.0) {
         break;
      }
  }

 

解析： 循环16.0/0.25 = 64(次)以后退出。

没错， 64次， 可能很多人会认为这个循环根本就不会退出，是个死循环 为什么呢， 因为x是一个浮点数，

浮点数是不能用来做精确比较的， 我只能说， 你的意识很好，但可能对浮点数的了解不够深入。

对浮点数介绍的文章很多，我这里只做一个总结：就是如果 x是2的整数次幂， 那么浮点数在内存中就是个确切值， 而不是大约值。

上面代码中：0.25 = 2^(-2),  16.0 = 2^4都是能在内存中确切表示的， 所以运算结果还是确定的。

如果把0.25改成0.1,  那么就不会是16.0/0.1 = 160次， 而是一个死循环了。

 

话要说回来， 浮点数的精确比较还是要慎用！

 

4.  p1,p2是否为两整形指针

#define INTPTR  int *

INTPTR   p1, p2;

 

解析： INTPTR p1, p2 作宏扩展后如下：

int * p1, p2;

明显p1 为整形指针， 而p2则是个整形。

这就是类型定义不用宏定义， 而用typedef 的原因,

用typedef 就不会有问题了:

typdef int * INTPTR;

INTPTR   p1, p2;

 

5. 下面程序在5秒之后主线程会退出吗？

static void*
_thread_entry(void *data)
{
    int* flag = (int*)(data);         

    *flag = 0;
    while(*flag != 1)
       sleep(1);

    printf("Thread exited!\n");
    return NULL;
}

int main()
{

     int arg = 0;
     pthread_t  tid;

     pthread_create(&tid, NULL, _thread_entry, (void*)&arg);

     sleep(5);
     arg = 1;

     pthread_join(tid, NULL);

     printf("Main exited....\n");

     return 0;
}

 

解析：尽管sleep 5秒后*flag会在子线程外部被改成1， 但结果是未必会退出。

原因是因为世界上还存在一个称为“编译器优化”的东东存在。

编译器优化会把内存变量缓存到寄存器， 这样程序会从寄存器去读，而不是从内存中去读。

外部主线程改变了这个值， 由于子线程还在寄存器中读取， 那岂不是白改变了呵呵。

 

要解决这个问题：让这个flag随时挥发吧， 这就让volatile关键字有了用武之地。

 int* flag = (int*)(data);  -> volatile   int* flag = (int*)(data);        

就能让世界平静了。