陈皓《深入理解C语言》学习笔记

1. 有关static变量的初始化

#include <stdio.h>

void f(void)
{
static int a = 3;
static int b;
int c;
++a; ++b; ++c;
printf("a=%d\n", a);
printf("b=%d\n", b);
printf("c=%d\n\n", c); /* 编译会警告：local variable 'c' used without having been initialized */
}

int main(void)
{
printf("第一次调用:\n");
f();
printf("第二次调用:\n");
f();
printf("第三次调用:\n");
f();

return 0; /* 这里要加上 */
}



这个程序会输出什么？

我相信你对a的输出相当有把握，就分别是4，5，6，因为那个静态变量。

对于c呢，你应该也比较肯定，那是一堆乱数。

但是你可能不知道b的输出会是什么？答案是1，2，3。为什么和c不一样呢？因为，如果要初始化，每次调用函数里，编译器都要初始化函数栈空间，这太费性能了。但是c的编译器会初始化静态变量为0，因为这只是在启动程序时的动作。

全局变量同样会被初始化。

说到全局变量，你知道 静态全局变量和一般全局变量的差别吗？是的，对于static 的全局变量，其对链接器不可以见，也就是说，这个变量只能在当前文件中使用。

2.编译优化开关

#include <stdio.h>

void foo(void)
{
int a;
printf("%d\n", a); /* 警告:local variable 'a' used without having been initialized */
}

void bar(void)
{
int a = 42;
}

int main(void)
{
bar();
foo();

return 0; /* 这个加上 */
}



你知道这段代码会输出什么吗？A) 一个随机值，B) 42。A 和 B都对（在“在函数外存取局部变量的一个比喻”文中的最后给过这个例子），不过，你知道为什么吗？

如果你使用一般的编译，会输出42，因为我们的编译器优化了函数的调用栈（重用了之前的栈），为的是更快，这没有什么副作用。反正你不初始化，他就是随机值，既然是随机值，什么都无所谓。

但是，如果你的编译打开了代码优化的开关，-O，这意味着，foo()函数的代码会被优化成main()里的一个inline函数，也就是说没有函数调用，就像宏定义一样。于是你会看到一个随机的垃圾数。

3.编译顺序影响移植性

#include <stdio.h>

int b(void) { printf("3"); return 3; }
int c(void) { printf("4"); return 4; }

int main(void)
{
int a = b() + c();
printf("%d\n", a);

return 0; /* 这个加上 */
}



4. Sequence Points

示例一

int a=41; a++; printf("%d\n", a);
示例二

int a=41; a++ & printf("%d\n", a);

示例三

int a=41; a++ && printf("%d\n", a);
示例四

int a=41; if (a++ < 42) printf("%d\n", a);
示例五

int a=41; a = a++; printf("%d\n", a);
只有示例一，示例三，示例四输出42，而示例二和五的行为则是未定义的。关于这种未定义的东西是因为Sequence Points的影响（Sequence Points是一种规则，也就是程序执行的序列点，在两点之间的表达式只能对变量有一次修改），因为这会让编译器不知道在一个表达式顺列上如何存取变量的值。比如a = a++，a + a++，不过，在C中，这样的情况很少。

5. 字节对齐

假设int为4字节，char为1字节。

#include <stdio.h>

struct X { int a; char b; int c; };

struct Y { int a; char b; int c; char d;};

int main(void)
{

printf("%d,", sizeof(struct X));
printf("%d\n", sizeof(struct Y));

return 0; /* 这个加上 */
}



这个代码会输出什么?

a) 9，10

b)12, 12

c)12, 16

答案是C，我想，你一定知道字节对齐，是向4的倍数对齐。

但是，你知道为什么要字节对齐吗？还是因为性能。因为这些东西都在内存里，如果不对齐的话，我们的编译器就要向内存一个字节一个字节的取，这样一来，struct X，就需要取9次，太浪费性能了，而如果我一次取4个字节，那么我三次就搞定了。所以，这是为了性能的原因。

但是，为什么struct Y不向12 对齐，却要向16对齐，因为char d; 被加在了最后，当编译器计算一个结构体的尺寸时，是边计算，边对齐的。也就是说，编译器先看到了int，很好，4字节，然后是 char，一个字节，而后面的int又不能填上还剩的3个字节，不爽，把char b对齐成4，于是计算到d时，就是13 个字节，于是就是16啦。但是如果换一下d和c的声明位置，就是12了。

另外，再提一下，上述程序的printf中的%d并不好，因为，在64位下，sizeof的size_t是unsigned long，而32位下是 unsigned int，所以，C99引入了一个专门给size_t用的%zu。这点需要注意。在64位平台下，C/C++ 的编译需要注意很多事。你可以参看《64位平台C/C++开发注意事项》。

6. 编译器warning

#include <stdio.h>
int main(void)
{
int a;
printf("%d\n", a);
}

考虑下面两种编译代码的方式 ：

cc -Wall a.c

cc -Wall -O a.c

前一种是不会编译出a未初化的警告信息的，而只有在-O的情况下，才会有未初始化的警告信息。这点就是为什么我们在makefile里的CFLAGS上总是需要-Wall和 -O。

7.指针

#include <stdio.h>
int main(void)
{
int a[5];

printf("%d\n\n", sizeof(int));
printf("%x\n", a);
printf("%x\n", a+1);
printf("%x\n", &a);
printf("%x\n", &a+1);

return 0;
}