C｜头文件包含的处理原则、规则、建议

大家好，欢迎来到IT知识分享网。

在C程序中，使用分离编译的原则，头文件(.h或.hpp)提供声明、接口的作用，源文件（.c）提供实现的作用，C编译器通常以源文件作为编译单元。编译时，根据声明来验证标识符，到了链接阶段，才去查找具体实现，并链接为一个整体。

另外，为了避免二义性，对于声明定义的原则是“多次声明（外部变量），一次定义”。在C工程中，为避免歧义，只能有一次定义，一次定义好的定义可以多次声明，以供在同一文件的定义前声明或其它作为编译单元的文件中使用。

关于声明和定义

1 定义通常涉及到内存分配，而声明不会；

2 定义的同时也是声明；如

int v_g; // 既是定义，也是声明

3 声明通常使用关键字extern；

extern int v_g; // 使用同文件中后面的外部变量或其它文件中定义的外部变量

4 如果了extern声明的同时进行了初始化，则是定义；

extern const int vc_g = 28; // const默认为内部链接，显示声明为extern后为外部链接

源文件中实现变量、函数的定义，并指定链接范围。头文件中书写外部需要使用的全局变量、函数声明及数据类型和宏的定义。

Unix编译器和链接器常使用允许多重定义的“通用模式”，只要保证最多对一处定义进行初始化即可。

该方式被ANSI C标准称为一种“通用扩展”。某些很老的系统可能要求显式初始化以区别定义和外部声明。

通用扩展在《深入理解计算机系统》中解释为：多重定义的符号只允许最多一个强符号。函数和定义时已初始化的全局变量是强符号；未初始化的全局变量是弱符号。Unix链接器使用以下规则来处理多重定义的符号：

规则一：不允许有多个强符号。在被多个源文件包含的头文件内定义的全局变量会被定义多次(预处理阶段会将头文件内容展开在源文件中)，若在定义时显式地赋值(初始化)，则会违反此规则。

规则二：若存在一个强符号和多个弱符号，则选择强符号。

规则三：若存在多个弱符号，则从这些弱符号中任选一个。

当不同文件内定义同名(即便类型和含义不同)的全局变量时，该变量共享同一块内存(地址相同)。若变量定义时均初始化，则会产生重定义(multiple definition)的链接错误；若某处变量定义时未初始化，则无链接错误，仅在因类型不同而大小不同时可能产生符号大小变化(size of symbol `XXX’ changed)的编译警告。

在最坏情况下，编译链接正常，但不同文件对同名全局变量读写时相互影响，引发非常诡异的问题。这种风险在使用无法接触源码的第三方库时尤为突出。

C工程通常文件来实现模块化，模块化的要求是“高内聚、低耦合。”

以及三个原则可以衍生出一系统头文件包含的处理原则、规则、建议

目录：

1 原则

1.1 头文件中适合放置接口的声明，不适合放置实现。

1.2 头文件应当职责单一。

1.3 头文件划分原则

1.4 头文件的语义层次化原则及使用通用头文件

1.5 头文件的语义相关性原则

1.6 源文件内的头文件包含顺序应从最特殊到一般。

1.7 精减原则：使用前置声明和extern函数声明，能不包含就不包含头文件

2 规则

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

2.2 禁止头文件循环依赖，减少嵌套和交叉引用，尽量避免顺序依赖

2.3 尽量在源文件中包含头文件，而非在头文件中。.c/.h文件禁止包含用不到的头文件

2.4 头文件应当自包含和自完备的。

2.5 头文件应包含哪些头文件仅取决于自身，而非包含该头文件的源文件

2.6 总是编写内部#include保护符（ #define 保护）。

27 禁止在头文件中定义变量。

2.8 只能通过包含头文件的方式使用其他.c提供的接口，

禁止在.c中通过extern的方式使用外部函数接口、变量。

2.9 禁止在extern “C”中包含头文件。

3 建议

3.1 一个模块通常包含多个.c文件，建议放在同一个目录下，目录名即为模块名。

为方便外部使用者，建议每一个模块提供一个.h，文件名为目录名。

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

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

3.4 同一产品统一包含头文件排列方式。

曾以为，一个.c文件对应一个.h文件，.c文件只包含它自身的.h文件就好，若.c文件中用到其他文件中的内容，则.h文件把用到的头文件包含进来就可以了。貌似可以一直秉承这个理念在进行代码编写。工程文件数量小时，这种理念貌似看不出问题，但随着工程文件数量越来越多，会发现自己这种思路有了弊端：头文件互相包含，导致编译时自以为有些宏变量声明了，它就能起作用，但实际测试发现这种方式编码后，有些声明的宏没能起到作用。(.h文件采用了避免重复包含的extern”C”的写法)

其实这是一个不正确的代码编写习惯，应该秉承.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.1：头文件中适合放置接口的声明，不适合放置实现。

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

内部使用的函数（相当于类的私有方法）声明不应放在头文件中。

内部使用的宏、枚举、结构定义不应放入头文件中。

变量定义不应放在头文件中，而应放在.c文件中。

变量的声明尽量不要放在头文件中，亦即尽量不要使用全局变量作为接口 。变量是模块或单元的内部实现细节，不应通过在头文件中声明的方式直接暴露给外部，应通过函数接口的方式进行对外暴露。 即使必须使用全局变量，也只应当在.c中定义全局变量，在.h中仅声明变量为全局的。

头文件内不允许定义变量和函数，只能有宏、类型(typedef/struct/union/enum等)及变量和函数的声明。特殊情况下可extern基本类型的全局变量，源文件通过包含该头文件访问全局变量。但头文件内不应extern自定义类型(如结构体)的全局变量，否则将迫使本不需要访问该变量的源文件包含自定义类型所在头文件。

「【注】全局变量的使用原则」

1）若全局变量仅在单个源文件中访问，则可将该变量改为该文件内的静态全局变量；

2）若全局变量仅由单个函数访问，则可将该变量改为该函数内的静态局部变量；

3）尽量不要使用extern声明全局变量，最好提供函数访问这些变量。直接暴露全局变量是不安全的，外部用户未必完全理解这些变量的含义。

4）设计和调用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题。

延伸阅读材料： 《 C语言接口与实现》 （ David R. Hanson 著 傅蓉 周鹏 张昆琪 权威 译 机械工业出版社 2004年1月） （英文版： “C Interfaces and Implementations”）

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

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

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

原则1.3：头文件划分原则

类型定义、宏定义尽量与函数声明相分离，分别位于不同的头文件中。内部函数声明头文件与外部函数声明头文件相分离，内部类型定义头文件与外部类型定义头文件相分离。

注意，类型和宏定义有时无法分拆为不同文件，比如结构体内数组成员的元素个数用常量宏表示时。因此仅分离类型宏定义与函数声明，且分别置于*.th和*.fh文件(并非强制要求)。

原则1.4：头文件的语义层次化原则及使用通用头文件

头文件需要有语义层次。不同语义层次的类型定义不要放在一个头文件中，不同层次的函数声明不要放在一个头文件中。

对于函数库(包括标准库和自定义的公共宏及接口)的头文件，可将其加入到一个通用头文件中。需要控制该头文件的体积(主要是该头文件所包含的所有头文件内容大小)，并确保所有源文件首先包含该通用头文件。

#ifndef _OMCI_COMMON_H #define _OMCI_COMMON_H /******************************************************************************************* * 说明: * 本文件仅应包含与具体通信协议无关的通用数据类型及宏定义。 * 为简化头文件包含且不失可移植性，本文件内可包含少量C库通用头文件。 * 因本文件内定义基本数据类型别名，故.c文件中应将本头文件置于包含列表顶端， * 否则编译时可能产生类型未定义错误。 *******************************************************************************************/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/time.h> #include <limits.h> #include "Omci_Byte.h" //<Other Contents...>

原则1.5：头文件的语义相关性原则

同一头文件中出现的类型定义、函数声明应该是语义相关的、有内部逻辑关系的，避免将无关的定义和声明放在一个头文件中。

原则1.6：源文件内的头文件包含顺序应从最特殊到一般

优点是每个头文件必须include需要的关联头文件，否则会报错。同时，源文件同名头文件置于包含列表前端便于检查该头文件是否自完备，以及类型或函数声明是否与标准库冲突。

#include "通用头文件" //内部可能定义本模块数据类型别名 #include "源文件同名头文件" #include "本模块其他头文件" #include "自定义工具头文件" #include "第三方头文件" #include "平台相关头文件" #include "C++库头文件" #include "C库头文件"

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

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

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

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

原则1.7：精减原则：使用前置声明和extern函数声明，能不包含就不包含头文件

头文件中若能前置声明，就不要包含另一头文件。仅当前置声明不能满足或过于麻烦时才使用include，如此可减少依赖性方面的问题。示例如下：

避免包含重量级的平台头文件，如windows.h或d3d9.h等。若仅使用该头文件少量函数，可extern函数到源文件内。若还使用该头文件某些类型和宏定义，可创建适配性源文件。在该源文件内包含平台头文件，封装新的接口并将其声明在同名头文件内，其他源文件将通过适配头文件间接访问平台接口。

规则2.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.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的源代码重新编译。

例如，头文件A中出现的类型定义在头文件B中，则头文件A应包含头文件B，除此以外的其他头文件不允许包含。

头文件的嵌套和交叉引用会使程序组织结构和文件组织变得混乱，同时造成潜在的错误。大型工程中，原有头文件可能会被多个其他(源或头)文件包含，在原有头文件中添加新的头文件往往牵一发而动全身。若头文件中类型定义需要其他头文件时，可将其提出来单独形成一个全局头文件。

规则2.3：尽量在源文件中包含头文件，而非在头文件中。.c/.h文件禁止包含用不到的头文件

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

规则2.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中多包含任何满足自包含之外的其他头文件。

头文件应是自完备的，即在任一源文件中包含任一头文件而不会产生编译错误。尽量保证用户使用此头文件时，无需手动包含其他前提头文件，即此头文件内已包含前提头文件。

例如，面积相关操作的头文件Area.h内已包含关于点操作的头文件Point.h，则用户包含Area.h后无需再手动包含Point.h。这样用户就不必了解头文件的内在依赖关系。

规则2.5：头文件应包含哪些头文件仅取决于自身，而非包含该头文件的源文件

例如，编译源文件时需要用到头文件B，且源文件已包含头文件A，而索性将头文件B包含在头文件A中，这是错误的做法。

规则2.6：总是编写内部#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)前面。

使用#pragma once或header guard(亦称include guard或macro guard)避免头文件重复包含。#pragma once是一种非标准但已被现代编译器广泛支持的技巧，它明确告知预处理器“不要重复包含当前头文件”。而header guard则通过预处理命令模拟类似行为：

#ifndef _PRJ_DIR_FILE_H //必须确保header guard宏名永不重名 #define _PRJ_DIR_FILE_H //<头文件内容> #endif

使用#pragma once相比header guard具有两个优点：

• 更快。编译器不会第二次读取标记#pragma once的文件，但却会读若干遍使用header guard 的文件(寻找#endif)；
• 更简单。不再需要为每个文件的header guard取名，避免宏名重名引发的“找不到声明”问题。缺点则是：
• #pragma once保证物理上的同一个文件不会被包含多次，无法对头文件中的一段代码作#pragma once声明。若某个头文件具有多份拷贝(内容相同的多个文件)，pragma不能保证它们不被重复包含。当然，这种重复包含很容易被发现并修正。
• 而#pragma once仅由编译器提供保证，存在可移植性等问题。
• 还有种写法同时使用#pragma once和header guard编写“可移植性”代码，以利用编译器可能支持的#pragma once优化。如下：

#pragma once #ifndef _PRJ_DIR_FILE_H #define _PRJ_DIR_FILE_H //<头文件内容> #endif

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

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

规则2.8：只能通过包含头文件的方式使用其他.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] 。

规则2.9：禁止在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” { ... }

建议3.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声明接口。

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

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

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

说明：目前很多产品中使用了.inc作为头文件扩展名，这不符合c语言的习惯用法。在使用.inc作为头文件扩展名的产品，习惯上用于标识此头文件为私有头文件。但是从产品的实际代码来看，这一条并没有被遵守，一个.inc文件被多个.c包含比比皆是。本规范不提倡将私有定义单独放在头文件中，具体见 规则1.1。

除此之外，使用.inc还导致source insight、 Visual stduio等IDE工具无法识别其为头文件，导致很多功能不可用，如“跳转到变量定义处”。虽然可以通过配置，强迫IDE识别.inc为头文件，但是有些软件无法配置，如Visual Assist只能识别.h而无法通过配置识别.inc。

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

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

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

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

其它：

1 头文件名应尽量与实现功能的源文件相同，即module.c和module.h。但源文件不一定要包含其同名的头文件。

2 头文件中不应包含本地数据，以降低模块间耦合度。

即只有源文件自己使用的类型、宏定义和变量、函数声明，不应出现在头文件里。作用域限于单文件的私有变量和函数应声明为static，以防止外部调用。将私有类型置于源文件中，会提高聚合度，并减少不必要的格式外漏。

3 说明性头文件不需要有对应的源文件。此类头文件内大多包含大量概念性宏定义或枚举类型定义，不包含任何其他类型定义和变量或函数声明。此类头文件也不应包含任何其他头文件。

4 C++中要引用C函数时，函数所在头文件内应包含extern “C”。

//.h文件头部 #ifdef __cplusplus extern "C" { #endif //<函数声明> //.h文件尾部 #ifdef __cplusplus } #endif

被extern “C”修饰的变量和函数将按照C语言方式编译和连接，否则编译器将无法找到C函数定义，从而导致链接失败。

5 头文件内要有面向用户的充足注释，从应用角度描述接口暴露的内容。

代码文件组织原则

建议C语言项目中代码文件组织遵循以下原则：

1）使用层次化和模块化的软件开发模型。每个模块只能使用所在层和下一层模块提供的接口。

2）每个模块的文件(可能多个)保存在一个独立文件夹中。

模块文件较多时可采用子目录的方式，物理上隔离不同层次的文件。子目录下源文件和头文件应分开存放，如分别置入include和source目录。

3）用于模块裁减的条件编译宏保存在一个独立文件中，便于软件裁减。

4）硬件相关代码和操作系统相关代码与工程代码相对独立保存，以便于软件移植。

5）按相同功能或相关性组织源文件和头文件。同一文件内的聚合度要高，不同文件中的耦合度要低。

在对既有工程做单元测试时，耦合度低的文件布局非常便于搭建环境。

6）声明和定义分开，使用头文件暴露模块需要提供给外部的类型、宏、变量和函数。尽量做到模块对外部透明，用户在使用模块功能时无需了解具体的实现。

7）作为对外接口的头文件一经发布，应保持稳定。修改时一定要慎重。

8）文件夹和文件命名要能够反映出模块的功能。

9）正式版本和测试版本使用统一文件，使用宏控制是否产生测试输出。

10）必要的注释不可缺少。

注释：

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

[a2] 自包含是指一个文件做为单独的模块，尽量避免自己的声明声明依赖外部的接口而产生包含，自包含也就是尽量要做到自我实现，实现尽可能少的包含和依赖。

[a3] 这种做法应该尽量避免，而是通过调用头文件的方式来使用该函数。

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

ref:

https://blog.csdn.net/fengcq126/article/details/

https://mp.weixin..com/s/ZEGSQKp75FuRyJpfSdrOoQ

－End－