C/C++ 头文件 “ 细节 ”

很多事不深入以为自己懂了，但真正用到项目上，才发现了问题。曾以为自己写C语言已经轻车熟路了，特别是对软件文件的工程管理上，因为心里对自己的代码编写风格还是有自信的。(毕竟刚毕业时老大对我最初的训练就是编码格式的规范化处理)

曾以为，一个 .c 文件对应一个 .h 文件,.c 文件只包含它自身的 .h 文件就好，若 .c 文件中用到其他文件中的内容，则 .h 文件把用到的头文件包含进来就可以了。

自己貌似一直秉承这个理念在进行代码编写（好可怕）。工程文件数量小时，这种理念貌似看不出问题，但随着工程文件数量越来越多，我发现自己这种思路有了弊端：头文件互相包含，导致编译时自以为有些宏变量声明了，它就能起作用，但实际测试发现这种方式编码后，有些声明的宏没能起到作用。

经过领导及同事的指正，自己才明白原有的代码编写习惯不正确。应该秉承 .c 文件对应的 .h 文件只包含头文件里用到的其它文件的头文件,任何非必须的 .h 文件不要包含；而 .c 文件里面要包含用到的所有 .h 文件。这样写即使存在 .c 文件内头文件重复包含也不伤大雅。

语言描述有时太抽象，还是符号举例说明下：假如有两个 .c 文件分别为 A.c 和 B.c，自然它们都有各自的 A.h 和 B.h 文件。

原有的思路：

A.c 里面只有一个#include "A.h",而 A.h 所包含的就是一大堆如 B.h,C.h,D.h..... 文件，因为 A.c 文件里面要用到 B.h,C.h,D.h 里面的内容。如下图所示。

新思路：

A.h 里面只包含 A.h 所写内容要用到的 .h 文件,很多时候 A.h 里面无需任何 .h 文件，而在 A.c 文件内就要写成  #include "B.h"  #include "C.h"  #include "D.h"。而且两个文件的 .c 文件在头文件包含上可以互相包含。如下图所示。

项目中遇到的这个头文件包含问题导致我重新搜索资料进行该问题的深入了解，故下文是通过网络资源的搜查及加上自己对它的理解，进行了相关内容的整理，希望对感兴趣的小伙伴有所帮助。

背景

对于 C 语言来说，头文件的设计体现了大部分的系统设计。不合理的头文件布局是编译时间过长的根因，不合理的头文件实际上不合理的设计。

依赖

特指编译依赖。若 x.h 包含了 y.h，则称作 x 依赖 y。依赖关系会进行传导，如 x.h 包含 y.h，而 y.h 又包含了 z.h，则 x 通过 y 依赖了 z。依赖将导致编译时间的上升。

虽然依赖是不可避免的，也是必须的，但是不良的设计会导致整个系统的依赖关系无比复杂，使得任意一个文件的修改都要重新编译整个系统，导致编译时间巨幅上升。

在一个设计良好的系统中， 修改一个文件，只需要重新编译数个，甚至是一个文件。

某产品曾经做过一个实验，把所有函数的实现通过工具注释掉，其编译时间只减少了不到 10%，究其原因，在于 A 包含 B， B 包含 C， C 包含 D，最终几乎每一个源文件都包含了项目组所有的头文件，从而导致绝大部分编译时间都花在解析头文件上。

某产品更有一个“优秀实践”，用于将 .c 文件通过工具合并成一个比较大的 .c 文件，从而大幅度提高编译效率。

其根本原因还是在于通过合并 .c 文件减少了头文件解析次数。但是，这样的“优秀实践”是对合理划分 .c 文件的一种破坏。

大部分产品修改一处代码，都得需要编译整个工程，对于 TDD 之类的实践，要求对于模块级别的编译时间控制在秒级，即使使用分布式编译也难以实现，最终仍然需要合理的划分头文件、以及头文件之间的包含关系， 从根本上降低编译时间。

《google C++ Style Guide》 1.2 头文件依赖 章节也给出了类似的阐述：若包含了头文件 aa.h，则就引入了新的依赖：一旦 aa.h 被修改，任何直接和间接包含 aa.h 代码都会被重新编译。如果 aa.h 又包含了其他头文件如 bb.h，那么 bb.h 的任何改变都将导致所有包含了 aa.h 的代码被重新编译。

在敏捷开发方式下，代码会被频繁构建，漫长的编译时间将极大的阻碍频繁构建。因此，我们倾向于减少包含头文件，尤其是在头文件中包含头文件，以控制改动代码后的编译时间。

合理的头文件划分体现了系统设计的思想，但是从编程规范的角度看，仍然有一些通用的方法，用来合理规划头文件。本章节介绍的一些方法，对于合理规划头文件会有一定的帮助。

原则1：头文件中适合放置接口的声明，不适合放置实现。

说明：头文件是模块（ Module）或单元（ Unit）的对外接口。头文件中应放置对外部的声明，如对外提供的函数声明、宏定义、类型定义等。

• 内部使用的函数（相当于类的私有方法）声明不应放在头文件中。
• 内部使用的宏、枚举、结构定义不应放入头文件中。
• 变量定义不应放在头文件中，应放在.c文件中。
• 变量的声明尽量不要放在头文件中，亦即尽量不要使用全局变量作为接口 。变量是模块或单元的内部实现细节，不应通过在头文件中声明的方式直接暴露给外部，应通过函数接口的方式进行对外暴露。

延伸阅读材料：《 C语言接口与实现》

原则2：头文件应当职责单一。

说明：头文件过于复杂，依赖过于复杂是导致编译时间过长的主要原因。很多现有代码中头文件过大，职责过多， 再加上循环依赖的问题，可能导致为了在 .c 中使用一个宏，而包含十几个头文件。

某个头文件不但定义了基本数据类型 WORD，还包含了stdio.h syslib.h等等不常用的头文件。

如果工程中有 10000 个源文件，而其中 100 个源文件使用了stdio.h的 printf，由于上述头文件的职责过于庞大，而 WORD 又是每一个文件必须包含的，从而导致stdio.h/syslib.h等可能被不必要的展开了 9900 次，大大增加了工程的编译时间。

原则3：头文件应向稳定的方向包含。

说明：头文件的包含关系是一种依赖，一般来说，应当让不稳定的模块依赖稳定的模块，从而当不稳定的模块发生变化时，不会影响（编译）稳定的模块。

就我们的产品来说，依赖的方向应该是：产品依赖于平台，平台依赖于标准库。某产品线平台的代码中已经包含了产品的头文件，导致平台无法单独编译、发布和测试， 是一个非常糟糕的反例。

除了不稳定的模块依赖于稳定的模块外，更好的方式是两个模块共同依赖于接口，这样任何一个模块的内部实现更改都不需要重新编译另外一个模块。在这里，我们假设接口本身是最稳定的。

延伸阅读材料：编者推荐开发人员使用“依赖倒置”原则，即由使用者制定接口，服务提供者实现接口，更具体的描述可以参见《 敏捷软件开发：原则、模式与实践》 （ Robert C.Martin 著 邓辉 译 清华大学出版社 2003 年 9 月） 的第二部分“敏捷设计”章节。

规则1：每一个 .c 文件应有一个同名 .h 文件，用于声明需要对外公开的接口。

说明：如果一个 .c 文件不需要对外公布任何接口，则其就不应当存在，除非它是程序的入口，如 main 函数所在的文件。

现有某些产品中，习惯一个 .c 文件对应两个头文件，一个用于存放对外公开的接口，一个用于存放内部需要用到的定义、声明等，以控制 .c 文件的代码行数。编者不提倡这种风格。

这种风格的根源在于源文件过大，应首先考虑拆分 .c 文件，使之不至于太大。另外，一旦把私有定义、声明放到独立的头文件中，就无法从技术上避免别人 include 之，难以保证这些定义最后真的只是私有的。

本规则反过来并不一定成立。有些特别简单的头文件，如命令 ID 定义头文件，不需要有对应的 .c 存在 [a1] 。

示例：对于如下场景，如在一个 .c 中存在函数调用关系：

void foo()
{
 bar();
}

void bar()
{
 Do something;
}

必须在 foo 之前声明 bar，否则会导致编译错误。

这一类的函数声明，应当在 .c 的头部声明，并声明为 static 的，如下：

static void bar();

void foo()
{
 bar();
}

void bar()
{
 Do something;
}

规则2：禁止头文件循环依赖。

说明：头文件循环依赖，指 a.h 包含 b.h， b.h 包含 c.h， c.h 包含 a.h 之类导致任何一个头文件修改，都导致所有包含了 a.h/b.h/c.h 的代码全部重新编译一遍。

而如果是单向依赖，如 a.h 包含 b.h， b.h 包含 c.h，而 c.h 不包含任何头文件，则修改 a.h 不会导致包含了 b.h/c.h 的源代码重新编译。

规则3：.c/.h 文件禁止包含用不到的头文件。

说明：很多系统中头文件包含关系复杂，开发人员为了省事起见，可能不会去一一钻研，直接包含一切想到的头文件，甚至有些产品干脆发布了一个 god.h，其中包含了所有头文件，然后发布给各个项目组使用，这种只图一时省事的做法，导致整个系统的编译时间进一步恶化，并对后来人的维护造成了巨大的麻烦。

规则4：头文件应当自包含。

说明：简单的说，自包含就是任意一个头文件均可独立编译。如果一个头文件包含某个头文件，还要包含另外一个头文件才能工作的话，就会增加交流障碍，给这个头文件的用户增添不必要的负担 [a2] 。

示例：如果 a.h 不是自包含的，需要包含 b.h 才能编译，会带来的危害：每个使用 a.h 头文件的 .c 文件，为了让引入的 a.h 的内容编译通过，都要包含额外的头文件 b.h。额外的头文件 b.h 必须在 a.h 之前进行包含，这在包含顺序上产生了依赖。

注意：该规则需要与“.c/.h 文件禁止包含用不到的头文件”规则一起使用，不能为了让 a.h 自包含，而在 a.h 中包含不必要的头文件。a.h 要刚刚可以自包含，不能在 a.h 中多包含任何满足自包含之外的其他头文件。

规则5：总是编写内部 #include 保护符（ #define 保护）。

说明：多次包含一个头文件可以通过认真的设计来避免。如果不能做到这一点，就需要采取阻止头文件内容被包含多于一次的机制。

通常的手段是为每个文件配置一个宏，当头文件第一次被包含时就定义这个宏，并在头文件被再次包含时使用它以排除文件内容。

所有头文件都应当使用 #define 防止头文件被多重包含，命名格式为FILENAME_H，为了保证唯一性，更好的命名是PROJECTNAME_PATH_FILENAME_H。

注：没有在宏最前面加上 ““，即使用FILENAME_H代替_FILENAME_H，是因为一般以 ”“ 和 ”“ 开头的标识符为系统保留或者标准库使用，在有些静态检查工具中，若全局可见的标识符以 ”” 开头会给出告警。

定义包含保护符时，应该遵守如下规则：

1. 保护符使用唯一名称；
2. 不要在受保护部分的前后放置代码或者注释。

示例：假定VOS工程的timer模块的timer.h，其目录为VOS/include/timer/timer.h,应按如下方式保护：

#ifndef VOS_INCLUDE_TIMER_TIMER_H

#define VOS_INCLUDE_TIMER_TIMER_H

...

#endif

也可以使用如下简单方式保护:

#ifndef TIMER_H

#define TIMER_H

..

#endif

例外情况：头文件的版权声明部分以及头文件的整体注释部分（如阐述此头文件的开发背景、使用注意事项等）可以放在保护符(#ifndef XX_H)前面。

规则6：禁止在头文件中定义变量。

说明：在头文件中定义变量，将会由于头文件被其他 .c 文件包含而导致变量重复定义。

规则7：只能通过包含头文件的方式使用其他 .c 提供的接口，禁止在 .c 中通过 extern 的方式使用外部函数接口、变量 [a3] 。

说明：若 a.c 使用了 b.c 定义的 foo() 函数，则应当在 b.h 中声明extern int foo(int input)；并在 a.c 中通过#include 来使用 foo。

禁止通过在 a.c 中直接写extern int foo(int input);来使用 foo，后面这种写法容易在 foo 改变时可能导致声明和定义不一致 [a4] 。

规则8：禁止在extern “C”中包含头文件。

说明：在extern “C”中包含头文件， 会导致extern “C”嵌套， Visual Studio对extern “C”嵌套层次有限制，嵌套层次太多会编译错误。

在extern “C”中包含头文件，可能会导致被包含头文件的原有意图遭到破坏。例如，存在 a.h 和 b.h 两个头文件：

使用 C++ 预处理器展开 b.h，将会得到

extern "C"
{
  void foo(int);
  void b();
}

按照 a.h 作者的本意，函数 foo 是一个 C++ 自由函数，其链接规范为 ”C++”。但在 b.h 中，由于#include “a.h”被放到了extern “C” { }的内部，函数 foo 的链接规范被不正确地更改了。

示例：错误的使用方式：

extern "C"
{
  #include "xxx.h"
  ...
}

正确的使用方式：

#include "xxx.h"

extern "C"
{
  ...
}

建议1：一个模块通常包含多个 .c 文件，建议放在同一个目录下，目录名即为模块名。为方便外部使用者，建议每一个模块提供一个 .h，文件名为目录名。

说明：需要注意的是，这个 .h 并不是简单的包含所有内部的 .h，它是为了模块使用者的方便，对外整体提供的模块接口。

以 Google test（简称GTest）为例， GTest 作为一个整体对外提 供 C++ 单元测试框架，其 1.5 版本的 gtest 工程下有 6 个源文件和 12 个头文件。

但是它对外只提供一个 gtest.h，只要包含 gtest.h 即可使用 GTest 提供的所有对外提供的功能，使用者不必关系 GTest 内部各个文件的关系，即使以后 GTest 的内部实现改变了，比如把一个源文件 c 拆成两个源文件，使用者也不必关心，甚至如果对外功能不变，连重新编译都不需要。

对于有些模块，其内部功能相对松散，可能并不一定需要提供这个 .h，而是直接提供各个子模块或者 .c 的头文件。

比如产品普遍使用的 VOS，作为一个大模块，其内部有很多子模块，他们之间的关系相对比较松散，就不适合提供一个 vos.h。而 VOS 的子模块，如 Memory（仅作举例说明，与实际情况可能有所出入），其内部实现高度内聚，虽然其内部实现可能有多个 .c 和 .h，但是对外只需要提供一个 Memory.h 声明接口。

建议2：如果一个模块包含多个子模块，则建议每一个子模块提供一个对外的 .h，文件名为子模块名。

说明：降低接口使用者的编写难度。

建议3：头文件不要使用非习惯用法的扩展名，如.inc。

说明：目前很多产品中使用了 .inc 作为头文件扩展名，这不符合 c语言的习惯用法。在使用 .inc 作为头文件扩展名的产品，习惯上用于标识此头文件为私有头文件。

但是从产品的实际代码来看，这一条并没有被遵守，一个 .inc 文件被多个 .c 包含比比皆是。本规范不提倡将私有定义单独放在头文件中，具体见 规则 1.1。

除此之外，使用 .inc 还导致 source insight、 Visual stduio 等 IDE 工具无法识别其为头文件，导致很多功能不可用，如“跳转到变量定义处”。

虽然可以通过配置，强迫 IDE 识别 .inc 为头文件，但是有些软件无法配置，如 Visual Assist 只能识别 .h 而无法通过配置识别. inc。

建议4：同一产品统一包含头文件排列方式。

说明：常见的包含头文件排列方式：功能块排序、文件名升序、稳定度排序。

以稳定度排序，建议将不稳定的头文件放在前面，如把产品的头文件放在平台的头文件前面，如下：

相对来说， product.h 修改的较为频繁，如果有错误,不必编译 platform.h 就可以发现 product.h 的错误，可以部分减少编译时间。

[a1] 例如一些屏驱动的地址文件,一些协议的格式定义文件.只存在 .c 或者 .h 即可,不一定两者都要有。

[a2] 我对自包含没有太理解，只是明白在 .h 文件里尽量不包含没有必要的头文件,某些情况下不得已才进行包含其它头文件的操作。

[a3] 这种做法我写代码常用,但后面应该尽量避免,而是通过调用头文件的方式来使用该函数。

[a4] 对，我就遇到过。因为随着工程量的增大，后面某个细节调整了 foo 函数,但其它 extern 调用它的地方没有及时改正,而 KEIL 编译器又没有报错,导致 bug 出现,而且不易查找。

文章链接：https://blog.csdn.net/fengcq126/article/details/103016917