C++ 编译模型

C++继承了C的编译模型,而C是一门古老的语言,它的编译链接模型受限于当时的硬件条件限制,并且该模型也足够用于简洁的C。而C++继承了这些机制之后,引发了更为复杂的一些问题。


C 编译模型

首先简要介绍一下C的编译模型:

限于当时的硬件条件,C编译器不能够在内存里一次性地装载所有程序代码,而需要将代码分为多个源文件,并且分别编译。并且由于内存限制,编译器本身也不能太大,因此需要分为多个可执行文件,进行分阶段的编译。在早期一共包括7个可执行文件:cc(调用其它可执行文件),cpp(预处理器),c0(生成中间文件),c1(生成汇编文件),c2(优化,可选),as(汇编器,生成目标文件),ld(链接器)。

1. 隐式函数声明

为了在减少内存使用的情况下实现分离编译,C语言还支持”隐式函数声明”,即代码在使用前文未定义的函数时,编译器不会检查函数原型,编译器假定该函数存在并且被正确调用,还假定该函数返回int,并且为该函数生成汇编代码。此时唯一不确定的,只是该函数的函数地址。这由链接器来完成。如:

1
2
3
4
5
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语言早期的头文件就是用来提供结构体定义和外部变量声明的,而外部符号(函数或外部变量)的决议则交给链接器去做。

单遍编译结合隐式函数声明,将引出一个有趣的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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 重载决议

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#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的隐式类型转换也给重载带来了麻烦:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 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 重复包含

由于头文件的传递性,有可能造成某上层头文件的重复包含。重复包含的头文件在展开后,将可能导致符号重定义,如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 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机制可以确保只到处必要的名字符号,不会有多余的符号加进来。