解析C语言与C++的编译模型

首先简要介绍一下C的编译模型：
限于当时的硬件条件，C编译器不能够在内存里一次性地装载所有程序代码，而需要将代码分为多个源文件，并且分别编译。并且由于内存限制，编译器本身也不能太大，因此需要分为多个可执行文件，进行分阶段的编译。在早期一共包括7个可执行文件：cc(调用其它可执行文件)，cpp(预处理器)，c0(生成中间文件)，c1(生成汇编文件)，c2(优化，可选)，as(汇编器，生成目标文件)，ld(链接器)。
1. 隐式函数声明
为了在减少内存使用的情况下实现分离编译，C语言还支持”隐式函数声明”，即代码在使用前文未定义的函数时，编译器不会检查函数原型，编译器假定该函数存在并且被正确调用，还假定该函数返回int，并且为该函数生成汇编代码。此时唯一不确定的，只是该函数的函数地址。这由链接器来完成。如：

int main()
{
 printf("ok\n");
 return 0;
}

在gcc上会给出隐式函数声明的警告，但能编译运行通过。因为在链接时，链接器在libc中找到了printf符号的定义，并将其地址填到编译阶段留下的空白中。PS：用g++编译则会生成错误：use of undeclared identifier 'printf'。而如果使用的是未经定义的函数，如上面的printf函数改为print，得到的将是链接错误，而不是编译错误。
2. 头文件
有了隐式函数声明，编译器在编译时应该就不需要头文件了，编译器可以按函数调用时的代码生成汇编代码，并且假定函数返回int。而C头文件的最初目的是用于方便文件之间共享数据结构定义，外部变量，常量宏。早期的头文件里，也只包含这三样东西。注意，没有提到函数声明。
而如今在引入将函数声明放入头文件这一做法后，带来了哪些便利和缺陷：
优点：
项目不同的文件之间共享接口。
头文件为第三方库提供了接口说明。
缺点：
效率性：为了使用一个简单的库函数，编译器可能要parse成千上万行预处理之后的头文件源码。
传递性：头文件具有传递性。在头文件传递链中任一头文件变动，都将导致包含该头文件的所有源文件重新编译。哪怕改动无关紧要(没有源文件使用被改动的接口)。
差异性：头文件在编译时使用，动态库在运行时使用，二者有可能因为版本不一致造成二进制兼容问题。
一致性：头文件函数声明和源文件函数实现的参数名无需一致。这将可能导致函数声明的意思，和函数具体实现不一致。如声明为 void draw(int height, int width) 实现为 void draw(int width, int height)。
3. 单遍编译( One Pass )
由于当时的编译器并不能将整个源文件的语法树保存在内存中，因此编译器实际上是”单遍编译”。即编译器从头到尾地编译源文件，一边解析，一边即刻生成目标代码，在单遍编译时，编译器只能看到已经解析过的部分。 意味着：
C语言结构体需要先定义，才能访问。因为编译器需要知道结构体定义，才知道结构体成员类型和偏移量，并生成目标代码。
局部变量必须先定义，再使用。编译器需要知道局部变量的类型和在栈中的位置。
外部变量(全局变量)，编译器只需要知道它的类型和名字，不需要知道它的地址，就能生成目标代码。而外部变量的地址将留给连接器去填。
对于函数，根据隐式函数声明，编译器可以立即生成目标代码，并假定函数返回int，留下空白函数地址交给连接器去填。
C语言早期的头文件就是用来提供结构体定义和外部变量声明的，而外部符号(函数或外部变量)的决议则交给链接器去做。
单遍编译结合隐式函数声明，将引出一个有趣的例子：

void bar()
{
 foo('a');
}

int foo(char a)
{
 printf("foobar\n");
 return 0;
}

int main()
{
 bar();
 return 0;
}

gcc编译上面的代码，得到如下错误：

test.c:16:6: error: conflicting types for 'foo'
void foo(char a)
 ^
test.c:12:2: note: previous implicit declaration is here
  foo('a');

这是因为当编译器在bar()中遇到foo调用时，编译器并不能看到后面近在咫尺的foo函数定义。它只能根据隐式函数声明，生成int foo(int)的函数调用代码，注意隐式生成的函数参数为int而不是char，这应该是编译器做的一个向上转换，向int靠齐。在编译器解析到更为适合的int foo(char)时，它可不会认错，它会认为foo定义和编译器隐式生成的foo声明不一致，得到编译错误。将上面的foo函数替换为 void foo(int a)也会得到类似的编译错误，C语言严格要求一个符号只能有一种定义，包括函数返回值也要一致。
而将foo定义放于bar之前，就编译运行OK了。
C++ 编译模型
到目前为止，我们提到的3点关于C编译模型的特性，对C语言来说，都是利多于弊的，因为C语言足够简单。而当C++试图兼容这些特性时(C++没有隐式函数声明)，加之C++本身独有的重载，类，模板等特性，使得C++更加难以理解。
1. 单遍编译
C++没有隐式函数声明，但它仍然遵循单遍编译，至少看起来是这样，单遍编译语义给C++带来的影响主要是重载决议和名字解析。
1.1 重载决议

#include<stdio.h>

void foo(int a)
{
 printf("foo(int)\n");
}

void bar()
{
 foo('a');
}

void foo(char a)
{
 printf("foo(char)\n");
}

int main()
{
 bar();
 return 0;
}

以上代码通过g++编译运行结果为：foo(int)。尽管后面有更合适的函数原型，但C++在解析bar()时，只看到了void foo(int)。
这是C++重载结合单遍编译造成的困惑之一，即使现在C++并非真的单遍编译(想一下前向声明)，但它要和C兼容语义，因此不得不”装傻”。对于C++类是个例外，编译器会先扫描类的定义，再解析成员函数，因此类中所有同名函数都能参加重载决议。
关于重载还有一点就是C的隐式类型转换也给重载带来了麻烦：

// Case 1
void f(int){}
void f(unsigned int){}
void test() { f(5); } // call f(int)

// Case 2
void f(int){}
void f(long){}
void test() { f(5); } // call f(int)

// Case 3
void f(unsigned int){}
void f(long){}
void test() { f(5); } // error. 编译器也不知道你要干啥

// Case 4
void f(unsigned int){}
void test{ f(5); } // call f(unsigned int)...
void f(long){}

再加上C++子类到父类的隐式转换，转换运算符的重载… 你必须费劲心思，才能确保编译器按你预想的去做。
1.2 名字查找
单遍编译给C++造成的另一个影响是名字查找，C++只能通过源码来了解名字的含义，比如 AA BB(CC)，这句话即可以是声明函数，也可以是定义变量。编译器需要结合它解析过的所有源代码，来判断这句话的确切含义。当结合了C++ template之后，这种难度几何攀升。因此不经意地改动头文件，或修改头文件包含顺序，都可能改变语句语义和代码的含义。
2. 头文件
在初学C++时，函数声明放在.h文件，函数实现放在.cpp文件，似乎已经成了共识。C++没有C的隐式函数声明，也没有其它高级语言的包机制，因此，同一个项目中，头文件已经成了模块与模块之间，类与类之间，共享接口的主要方式。
C中的效率性，传递性，差异性，一致性，C++都一个不落地继承了。除此之外，C++头文件还带来如下麻烦：
2.1 顺序性
由于C++头文件包含更多的内容：template, typedef, #define, #pragma, class,等等，不同的头文件包含顺序，将可能导致完全不同的语义。或者直接导致编译错误。
2.2 又见重载
由于C++支持重载，因此如果头文件中的函数声明和源文件中函数实现不一致(如参数个数，const属性等)，将可能构成重载，这个时候”聪明”的C++编译器不错报错，它将该函数的调用地址交给链接器去填，而源文件中写错了的实现将被认定为一个全新的重载。从而到链接阶段才报错。这一点在C中会得到编译错误，因为C没有重载，也就没有名字改编(name mangling)，将会在编译时得到符号冲突。
2.3 重复包含
由于头文件的传递性，有可能造成某上层头文件的重复包含。重复包含的头文件在展开后，将可能导致符号重定义，如：

// common.h
class Common
{
 // ...
};

// h1.h
#include "common.h"

// h2.h
#include "common.h"

// test.cpp
#include "h1.h"
#include "h2.h"
int main()
{
 return 0;
}

如果common.h中，有函数定义，结构体定义，类声明，外部变量定义等等。test.cpp中将展开两份common.h，编译时得到符号重定义的错误。而如果common.h中只有外部函数声明，则OK，因为函数可在多处声明，但只能在一处定义。关于类声明，C++类保持了C结构体语义，因此叫做”类定义”更为适合。始终记得，头文件只是一个公共代码的整合，这些代码会在预编译期替换到源文件中。
为了解决重复包含，C++头文件常用 #ifndef #define #endif或#pragma once来保证头文件不被重复包含。
2.4 交叉包含
C++中的类出现相互引用时，就会出现交叉包含的情况。如Parent包含一个Child对象，而Child类包含Parent的引用。因此相互包含对方的头文件，编译器展开Child.h需要展开Parent.h，展开Parent.h又要展开Child.h，如此无限循环，最终g++给出：error: #include nested too deeply的编译错误。
解决这个问题的方案是前向声明，在Child类定义前面加上 class Parent; 声明Parent类，而无需包含其头文件。前向声明不止可以用于类，还可以用于函数(即显式的函数声明)。前向声明应该被大量使用，它可以解决头文件带来的绝大多数问题，如效率性，传递性，重复包含，交叉包含等等。这一点有点像包(package)机制，需要什么，就声明(导入)什么。前向声明也有局限：仅当编译器无需知道目标类完整定义时。如下情形，类A可使用 class B;：
类A中使用B声明引用或指针；
类A使用B作为函数参数类型或返回类型，而不使用该对象，即无需知道其构造函数和析构函数或成员函数；
2.5 如何使用头文件
关于头文件使用的建议：
降低将文件间的编译依赖(如使用前向声明)；
将头文件归类，按照特定顺序包含，如C语言系统头文件，C++系统头文件，项目基础头文件，项目头文件；
防止头文件重复编译(#ifndef or #pragma)；
确保头文件和源文件的一致；
3.总结
C语言本身一些比较简单的特性，放在C++中却引起了很多麻烦，主要是因为C++复杂的语言特性：类，模板，各种宏… 举个例子来说，对于一个类A，它有一个私有函数，需要用到类B，而这个私有函数必须出现在类定义即头文件中，因此就增加了A头文件对B的不必要引用。这是因为C++类遵循C结构体的语义，所有类成员都必须出现在类定义中，”属于这个类的一部分”。这不仅在定义上造成不便，也在容易在语义上造成误解，事实上，C++类的成员函数不属于对象，它更像普通函数(虚函数除外)。
而在C中，没有”类的捆绑”，实现起来就要简单多了，将该函数放在A.c中，函数不在A.h中声明。由A.c包含B.h，解除了A.h和B.h之间的关联，这也是C将数据和操作分离的优势之一。
最后，看看其它语言是如何避免这些”坑”的：
对于解释型语言，import的时候直接将对应模块的源文件解析一遍，而不是将文件包含进来；
对于编译型语言，编译后的目标文件中包含了足够的元数据，不需要读取源文件(也就没有头文件一说了)；
它们都避免了定义和声明不一致的问题，并且在这些语言里面，定义和声明是一体的。import机制可以确保只到处必要的名字符号，不会有多余的符号加进来。