C语言头文件组织与包含原则介绍

james814

一、头文件作用
C语言里，每个源文件是一个模块，头文件为使用该模块的用户提供接口。接口指一个功能模块暴露给其他模块用以访问具体功能的方法。
' l# v( T* f* }使用源文件实现模块的功能，使用头文件暴露单元的接口。用户只需包含相应的头文件就可使用该头文件中暴露的接口。
通过头文件包含的方法将程序中的各功能模块联系起来有利于模块化程序设计:
1）通过头文件调用库功能。在很多场合，源代码不便(或不准)向用户公布，只要向用户提供头文件和二进制库即可。用户只需按照头文件中的接口声明来调用库功能，而不必关心接口如何实现。编译器会从库中提取相应的代码。
2）头文件能加强类型安全检查。若某个接口的实现或使用方式与头文件中的声明不一致，编译器就会指出错误。这一简单的规则能大大减轻程序员调试、改错的负担。
在预处理阶段，编译器将源文件包含的头文件内容复制到包含语句(#include)处。在源文件编译时，连同被包含进来的头文件内容一起编译，生成目标文件(.obj)。
如果所包含的头文件非常庞大，则会严重降低编译速度(使用GCC的-E选项可获得并查看最终预处理完的文件)。因此，在源文件中应仅包含必需的头文件，且尽量不要在头文件中包含其它头文件。
; u9 X' B: \  v5 @0 Z二、 头文件组织原则

源文件中实现变量、函数的定义，并指定链接范围。头文件中书写外部需要使用的全局变量、函数声明及数据类型和宏的定义。/ q. @; f; Z/ r8 |$ a/ _+ S
建议组织头文件内容时遵循以下原则：; j5 q% N4 T' G
9 v  A" c8 n" @1）头文件划分原则：类型定义、宏定义尽量与函数声明相分离，分别位于不同的头文件中。内部函数声明头文件与外部函数声明头文件相分离，内部类型定义头文件与外部类型定义头文件相分离。
9 q' b( w' _/ T* T' Y. I* N注意，类型和宏定义有时无法分拆为不同文件，比如结构体内数组成员的元素个数用常量宏表示时。因此仅分离类型宏定义与函数声明，且分别置于*.th和*.fh文件(并非强制要求)。
, _8 u  `' F+ p# X: S( w2）头文件的语义层次化原则：头文件需要有语义层次。不同语义层次的类型定义不要放在一个头文件中，不同层次的函数声明不要放在一个头文件中。
3）头文件的语义相关性原则：同一头文件中出现的类型定义、函数声明应该是语义相关的、有内部逻辑关系的，避免将无关的定义和声明放在一个头文件中。
4）头文件名应尽量与实现功能的源文件相同，即module.c和module.h。但源文件不一定要包含其同名的头文件。, @2 f6 n. m6 }1 A
) G% u' g, ?6 c/ d1 L, T5）头文件中不应包含本地数据，以降低模块间耦合度。$ j( h& h. [+ K6 N; |' X/ z
即只有源文件自己使用的类型、宏定义和变量、函数声明，不应出现在头文件里。作用域限于单文件的私有变量和函数应声明为static，以防止外部调用。将私有类型置于源文件中，会提高聚合度，并减少不必要的格式外漏。
2 o! U/ q! z* t  `* q' B  s* }6）头文件内不允许定义变量和函数，只能有宏、类型(typedef/struct/union/enum等)及变量和函数的声明。特殊情况下可extern基本类型的全局变量，源文件通过包含该头文件访问全局变量。但头文件内不应extern自定义类型(如结构体)的全局变量，否则将迫使本不需要访问该变量的源文件包含自定义类型所在头文件[1]。
7）说明性头文件不需要有对应的源文件。此类头文件内大多包含大量概念性宏定义或枚举类型定义，不包含任何其他类型定义和变量或函数声明。此类头文件也不应包含任何其他头文件。' q! f, p7 O( D+ n: h, c6 D7 W8 t% U6 E
9 U. s! ?9 Y0 L8）使用#pragma once或header guard(亦称include guard或macro guard)避免头文件重复包含。#pragma once是一种非标准但已被现代编译器广泛支持的技巧，它明确告知预处理器“不要重复包含当前头文件”。而header guard则通过预处理命令模拟类似行为：9 B; E7 v4 |- e, o, z
7 ]- I$ m' `/ t1 D0 c: H#ifndef  _PRJ_DIR_FILE_H  //必须确保header guard宏名永不重名
0 ]7 |/ B6 o  ]- {. W2 Y( g#define  _PRJ_DIR_FILE_H

//<头文件内容>( n* K, G. O! X6 z/ B  ~
6 l" N' C1 u( n( o' D6 p7 g- {: N
9 ]" ~3 F3 T: j#endif
. M9 u1 Y4 Z7 `2 A/ w: R/ p
2 V( g9 @+ w9 ^+ z
使用#pragma once相比header guard具有两个优点：

• 更快。编译器不会第二次读取标记#pragma once的文件，但却会读若干遍使用header guard 的文件(寻找#endif)；
• 更简单。不再需要为每个文件的header guard取名，避免宏名重名引发的“找不到声明”问题。
  + q) ?' C& w8 v/ }) W6 J6 @5 X缺点则是：
• #pragma once保证物理上的同一个文件不会被包含多次，无法对头文件中的一段代码作#pragma once声明。若某个头文件具有多份拷贝(内容相同的多个文件)，pragma不能保证它们不被重复包含。当然，这种重复包含很容易被发现并修正。7 t. H2 W0 B3 u0 k
  9） C++中要引用C函数时，函数所在头文件内应包含extern "C"。" u% V$ b% a7 E5 E' a$ E9 x
  : O: ]+ F# F# b7 Q3 b
  

//.h文件头部# w/ B- |# H- I7 ?, k: {' p
# r' `4 U! X5 c8 O% @#ifdef  __cplusplus" w1 ], M2 t9 q8 m" `$ {- F
extern "C" {+ W/ |, j; y1 s* F4 |. z* o) Z
#endif
) X- h7 E6 ]9 p& [$ z3 F: h! F3 T4 a0 ?; @
  T  @: S: K/ x6 V0 n  I//<函数声明>
. D6 @, M2 {, |5 z  Q0 `5 l
//.h文件尾部1 L& r  ~& |. _9 _2 c
#ifdef  __cplusplus
}
5 I+ n: }7 B. u0 v: ^. Y9 g* [#endif


被extern "C"修饰的变量和函数将按照C语言方式编译和连接，否则编译器将无法找到C函数定义，从而导致链接失败。
, |+ z  w7 g( M8 `/ Q10）头文件内要有面向用户的充足注释，从应用角度描述接口暴露的内容。
三、 头文件包含原则$ \: w( m6 c0 L7 @4 G
( Y5 B5 q$ P, h4 _. u$ ]
+ M0 K8 D  T) k1 }$ T在实际编程中，常常因头文件包含不当而引发编译时报告符号未定义的错误或重复定义的警告。要消除符号未定义的编译错误，只需在引用符号(变量、函数、数据类型及宏等)前确保它已被声明或定义[4]。要消除重复定义的警告，则需合理设计头文件包含顺序和层次。
建议包含头文件时遵循以下原则：
' ]' o% w# `' P, `1 Y; o$ u1）源文件内的头文件包含顺序应从最特殊到一般，如：
8 P) i' B* G  h2 N$ @4 W% b#include "通用头文件"  //内部可能定义本模块数据类型别名
#include "源文件同名头文件"0 `9 K8 U3 w* {" S& n
#include "本模块其他头文件"
#include "自定义工具头文件"% W4 H( j  ]8 b
+ B" K7 n: ^, c( _2 x" ]+ q) L#include "第三方头文件"
#include "平台相关头文件"
#include "C++库头文件"3 b# I& x. J" U6 R6 X5 P
#include "C库头文件"

- h& g% M9 x6 }; `; V+ j( Q$ }5 J0 P* ^1 s
优点是每个头文件必须include需要的关联头文件，否则会报错。同时，源文件同名头文件置于包含列表前端便于检查该头文件是否自完备，以及类型或函数声明是否与标准库冲突。
# V4 J3 E0 K$ `; j! ^( Z6 C2）减少头文件的嵌套和交叉引用，头文件仅包含其真正需要显式包含的头文件。
例如，头文件A中出现的类型定义在头文件B中，则头文件A应包含头文件B，除此以外的其他头文件不允许包含。1 G& e0 R8 D6 B4 R; z
- V0 ~& Z% V* [$ [/ X1 @) [/ y5 K头文件的嵌套和交叉引用会使程序组织结构和文件组织变得混乱，同时造成潜在的错误。大型工程中，原有头文件可能会被多个其他(源或头)文件包含，在原有头文件中添加新的头文件往往牵一发而动全身。若头文件中类型定义需要其他头文件时，可将其提出来单独形成一个全局头文件。+ M3 B, B: S$ E+ z1 D
: B' d1 N, s+ P% v3）头文件应包含哪些头文件仅取决于自身，而非包含该头文件的源文件。, y6 f' U4 }& H& W& Z! G! u
例如，编译源文件时需要用到头文件B，且源文件已包含头文件A，而索性将头文件B包含在头文件A中，这是错误的做法。
9 Y1 D! P" U: Z9 M4 v; Z4 G5 L  o3 ]4）尽量保证用户使用此头文件时，无需手动包含其他前提头文件，即此头文件内已包含前提头文件。
例如，面积相关操作的头文件Area.h内已包含关于点操作的头文件Point.h，则用户包含Area.h后无需再手动包含Point.h。这样用户就不必了解头文件的内在依赖关系。- y, |; F4 Y5 e5 }9 j- |) w$ H5 ?
, `" z: l/ v, ^( n5）头文件应是自完备的，即在任一源文件中包含任一头文件而不会产生编译错误。
6）源文件中包含的头文件尽量不要有顺序依赖。  \4 C3 d$ ~, B, z1 g* H: p
7）尽量在源文件中包含头文件，而非在头文件中。且源文件仅包含所需的头文件。
( H; S( b/ b& q8）头文件中若能前置声明(亦称前向声明[5])，就不要包含另一头文件。仅当前置声明不能满足或过于麻烦时才使用include，如此可减少依赖性方面的问题。示例如下：) _9 u8 w$ R& c7 P9 _1 h) s; q& Q
struct T_MeInfoMap;  //前置声明. u/ M- x$ Q7 V# J0 Z
* Q1 D. A# l& ^struct T_OmciMsg;    //前置声明4 Q+ f- a7 `% ?8 N; T$ d

typedef FUNC_STATUS (*OmciChkFunc)(struct T_MeInfoMap *ptMeInfo, struct T_OmciMsg *ptMsg, struct T_OmciMsg *ptAckMsg);
# P" P8 [# H! C  Q  k; N8 O) i! V$ e% ^* z, w& ?6 p* r, ~+ n
( }9 n& a# g" Q! d* r- A4 b) I6 a
//OMCI实体信息2 H+ g7 K4 V$ S) P
typedef struct{9 r- r! ?( v! L) j" G
6 F4 n& W3 d. S7 f/ Q. l! M    INT16U wMeClass;               //实体类别
* b/ D9 h  h4 k, ?7 r2 W    OMCI_ATTR_INFO *pMeAttrInfo;   //实体所定义的属性信息指针
    INT8U  ucAttrNum;              //实体所定义的属性数目& ]8 u; O" c! {9 Z7 ~
) G6 M2 |6 o5 ^& }4 t8 v: g    INT16U wTotalAttrLen;          //实体所有属性所占的总字节数，初始化为0，动态计算
    INT8U  *pszDbName;             //实体存库时的数据表名称，建议不要超过DB_NAME_LEN(32)
. `" p  B( ^" x; Y# V6 o  t    INT16U wMaxRecNum;             //实体存库时支持的最大记录数目
+ C+ ^/ i' Q2 z: t    OmciChkFunc fnCheck;           //Omci校验函数指针
8 y# g9 j% D7 ]) C. J% {    BOOL   bDbCreated;             //实体数据表是否已创建
}OMCI_ME_INFO_MAP;5 q0 n3 T8 g, g6 p6 s: w
" o' q% Y1 ]' ^4 _3 U- a9 o. Q) u6 u: t- X

如上，在OmciChkFunc函数的实现源文件内包含T_MeInfoMap和T_OmciMsg所在头文件即可。
% O1 c% |7 G( y2 ], y9 r/ C另举一例如下：
typedef TBL_SET_MODE (*OperTypeFunc)(INT8U *pTblEntry);+ }- O# p. z) X; F" c' {
  z# g2 O$ F' t" m  @. ?& K" l+ j5 ?; J! s
typedef INT8U (*CmpRecFunc)(VOID *pvCmpData, VOID *pvRecData); //为避免头文件交叉引用，与CompareRecFunc异名同构
* ?; g- i% S3 Z5 K* a, e! _
//表属性信息
typedef struct{
5 W3 D  B& v, d+ W+ C9 e9 C3 X    INT16U wMaxEntryNum;         //表属性最大表项数目(实体记录数目wMaxRecNum * wMaxEntryNum <= MAX_RECORD_NUM)2 a, e4 m: U7 [2 I$ B3 F) J" q+ e+ u
    OperTypeFunc fnGetOperType;  //操作类型函数指针。根据表项数据或外界需求(只读表)解析当前表项操作类型
! k. D* S8 A4 ^6 T    TBL_KEY_INFO tCmpKeyInfo;    //检索表属性子表记录时的匹配关键字信息(TBL_KEY_INFO)
. D! D- c8 W1 ?6 x* }/ A3 x    CmpRecFunc   fnCmpAddKey;    //增加表项时需要检测的关键字匹配函数指针; F5 w- [' H2 t% P& i  f3 f
9 b9 _2 {6 |. l" P5 s    CmpRecFunc   fnCmpDelKey;    //删除表项时需要检测的关键字匹配函数指针
. ?) w+ i( q2 Q0 [  Q  S$ F& S8 Q    INT16U wTblEntrySize;        //表属性表项字节数，由外部动态赋值" e0 m% t8 }( c4 x! ^/ P2 r
) }$ A: p" e' i4 f}TBL_ATTR_INFO;
8 }% w' r5 p, I. b2 }* k

6 E" d- o; W" L6 P! ~如上，CompareRecFunc函数原型由其他头文件提供，此处为避免头文件交叉引用定义其异名同构原型CmpRecFunc。
在不会引起歧义的前提下，头文件内尽可能使用VOID指针代替非基本类型的值变量或指针，以避免再包含类型定义所在的头文件。但这将影响代码可读性并降低程序执行效率，应权衡利弊。9 j/ t1 z. O  i* z
9）避免包含重量级的平台头文件，如windows.h或d3d9.h等。若仅使用该头文件少量函数，可extern函数到源文件内。如下：
& I6 e1 r2 x2 y8 R% ?( ?) ]8 f/****************************************************************************************
                       外部函数声明 (当外部接口未提供头文件或头文件过于复杂时)
****************************************************************************************/* n- @) M% m* P' G! y. x
" ~  @; P3 J- a, d0 Y* m; v/ A$ g1 B//因声明所在头文件引用混乱，此处仅extern函数声明。, o! m* f  S0 y
7 T% Z1 d. h0 l' Z# e- I- W0 `  U9 @extern INT32S DBShmCliInit(VOID); //#include "db_shm_mgr.h"; K, m0 ^( }/ d2 O. W+ I/ @) ~, f  j
extern INT32S cmLockInit(VOID);   //#include "common_cmapi.h": p; Z/ i# W4 ^
/ x& l7 N) }8 f
) A; J: O% q' }4 l( s0 M
若还使用该头文件某些类型和宏定义，可创建适配性源文件。在该源文件内包含平台头文件，封装新的接口并将其声明在同名头文件内，其他源文件将通过适配头文件间接访问平台接口。如下：3 d4 G! c! z4 C2 U- n
/*****************************************************************************************& x' U2 J/ ^/ g( ~# m
* 文件名称：Omci_Send_Msg.c, e" p0 M- c5 A
* 内容摘要：OMCI消息转发接口: j  X  R4 |; ]$ ?& Y: e% ^9 I
" J$ Z5 P: @" C) k6 J5 O+ n* 其它说明： 该头文件封装SEND接口，以避免其他源文件包含支撑api和pid公共头文件导致引用混乱。
; @$ w# _. {' H) D" r7 ?% l( i*****************************************************************************************/" \: e% @: [5 m: A; ]
6 r2 g4 g: o2 z- e3 D
#include "Omci_Common.h"
#include "Omci_Send_Msg.h"
#include "oss_api.h"+ F" t4 [+ L3 _0 q
6 E7 d! X) s, P% s6 P- G# Y/ O" q6 b6 M* ]  j
$ J9 z) v" A; a! p+ V/**********************************************************************************************
                                         函数实现区* w) i. O' o7 u" ^8 S/ h
**********************************************************************************************/
+ `  O1 f/ w0 ], G  l8 \4 `
//向自身进程发送异步消息
  W- f. _. V( M0 H! I6 rINT32U OmciAsynSendSelf(INT16U wEvent, VOID *pvMsg, INT16U wMsgLen)  p8 T: [9 H7 W* Z- r# ?
{; N+ t8 _( V& c% l  W
    PID dwSelfPid = 0;" }, j$ o- p. T! p, J- M5 i
9 a1 N5 D: J, B; C$ \3 v    SELF(&dwSelfPid);
! a& [: g* F  R9 R4 ~    return ASEND(wEvent, pvMsg, wMsgLen, dwSelfPid);
$ X2 _: k2 A5 X. L) t* B}+ _3 M/ A* D; O; G( A. U1 u6 @" i$ t


- B' U) f5 h2 z10）对于函数库(包括标准库和自定义的公共宏及接口)的头文件，可将其加入到一个通用头文件中。需要控制该头文件的体积(主要是该头文件所包含的所有头文件内容大小)，并确保所有源文件首先包含该通用头文件。示例如下：
  \. `$ r; R: k! E+ p% w9 a#ifndef  _OMCI_COMMON_H
#define  _OMCI_COMMON_H& ^/ W" c+ W. _7 X; q
% |+ V/ ]6 `) e. s! Y5 E8 R: z5 [+ G, t# n; V8 w1 P' I- _
/*******************************************************************************************# z5 M; E5 K0 \* L0 Z, b7 j( t
6 x) u8 H/ V3 o* 说明:/ E% d- P5 R% k
* 本文件仅应包含与具体通信协议无关的通用数据类型及宏定义。4 P0 B0 j. F1 r& e" T/ _3 {
# N$ ]' m+ D/ W" j8 ~& `* 为简化头文件包含且不失可移植性，本文件内可包含少量C库通用头文件。
- k% C: [% e: }0 r0 ]2 q; t/ N- h7 H% C+ ~* 因本文件内定义基本数据类型别名，故.c文件中应将本头文件置于包含列表顶端，
* 否则编译时可能产生类型未定义错误。9 q; s& J1 n+ n8 m' Y3 J& ?3 H+ S
4 e7 j* R( w' d: }4 s*******************************************************************************************/$ w4 ]* w2 W% G  c
) M8 ^9 q6 n' {: r. q& k& p, l, }& Y) p( w' W2 n+ Z4 z
#include <stdio.h>
#include <stdlib.h>% I2 K) g& F' n2 r4 g7 Z
#include <string.h>
#include <sys/time.h>
4 Q4 d9 _6 D9 \#include <limits.h>4 Z6 z) Z1 k( }/ B1 V% L5 Q5 f

  C* Q( D: q, }+ R5 g; Q' T#include "Omci_Byte.h"0 a) B5 q9 @# z& ?4 O9 n8 q
! D" B/ M5 Z" b; r6 e$ p( |5 Y6 w, }/ L# i+ g3 B: E( M2 C
! u5 }+ t+ f, I1 m, w9 I" d//<Other Contents...>8 v6 J1 ^/ J, N
" p/ H8 E& @! u& Q" N" V; V- {# c3 g( H4 y7 D$ h  f# h$ n
) P  q6 h2 ?( P! s; ?3 w- J8 \3 u( t$ W( v1 |; j1 e* _8 T
注意，示例头文件内包含C库文件虽能简化包含，但却与规则1冲突。也可另外增加包含库文件列表的通用头文件。; ]: R' E; I' ]3 u  Y1 I& i
% i/ ?6 i' D) H/ x1 x5 y11）若不确定类型、宏定义或函数声明所在头文件具体路径，可在源文件中再次定义或声明，编译器会以redefined警告或conflicting错误给出类型、宏定义或函数声明所在头文件路径。/ [: e0 ]0 q/ V
2 g( k* o7 a; U0 [% C" V3 e' q6 @四、代码文件组织原则

建议C语言项目中代码文件组织遵循以下原则：6 H, s% m' }1 j$ X0 B' t, h& ?
& K. Q. S) o" @, X0 P1）使用层次化和模块化的软件开发模型。每个模块只能使用所在层和下一层模块提供的接口。
; f/ ?2 x2 H3 [0 K4 J8 S2）每个模块的文件(可能多个)保存在一个独立文件夹中。, W( G6 z% B0 E
模块文件较多时可采用子目录的方式，物理上隔离不同层次的文件。子目录下源文件和头文件应分开存放，如分别置入include和source目录。
4 s) q1 g. s; {8 _3）用于模块裁减的条件编译宏保存在一个独立文件中，便于软件裁减。; P$ @5 o8 t; R- ^9 o1 s
4）硬件相关代码和操作系统相关代码与工程代码相对独立保存，以便于软件移植。
5）按相同功能或相关性组织源文件和头文件。同一文件内的聚合度要高，不同文件中的耦合度要低。
, w+ t3 Q5 b0 L( ]# I2 c在对既有工程做单元测试时，耦合度低的文件布局非常便于搭建环境。7 W3 w+ {& @3 m  A+ Y
, l. D: i8 @1 i' `7 |6 R6）声明和定义分开，使用头文件暴露模块需要提供给外部的类型、宏、变量和函数。尽量做到模块对外部透明，用户在使用模块功能时无需了解具体的实现。" O& c. Y- p; V$ \, K& ?* w7 o
, a- V- |- b% y2 Q9 K, d7）作为对外接口的头文件一经发布，应保持稳定。修改时一定要慎重。7 K8 }+ h* H2 P# }0 d6 n' W2 H
8）文件夹和文件命名要能够反映出模块的功能。
1 a; S+ s+ s' u$ Y9）正式版本和测试版本使用统一文件，使用宏控制是否产生测试输出。8 }8 C( _2 b* }; B$ @/ r
10）必要的注释不可缺少。6 X5 ?% @( @4 W/ }2 K* g$ c: z; c
五、 注解
- C# N. M+ p  u4 D( j; e: D- k% p1 b) A/ f# m) u9 s

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

/ K4 P" a5 T8 |
) @3 @( A% A0 T" U' W1）若全局变量仅在单个源文件中访问，则可将该变量改为该文件内的静态全局变量；
7 ?( X  R" g3 i2）若全局变量仅由单个函数访问，则可将该变量改为该函数内的静态局部变量；
- f6 e, u* f. F1 Y; G1 }$ E  U3）尽量不要使用extern声明全局变量，最好提供函数访问这些变量。直接暴露全局变量是不安全的，外部用户未必完全理解这些变量的含义。
. e5 B- J0 s. t3 F7 H: n4）设计和调用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题。

「【注2】#pragma once的可移植性」

) m1 J" a/ l. u5 @3 i+ h4 ^4 Q$ k/ ?. v
2 r$ g4 u/ b3 t  i* d5 b1 f% y#ifndef由C/C++语言标准支持，不受编译器任何限制；而#pragma once仅由编译器提供保证，存在可移植性等问题。5 L9 u9 T- v& A  L
6 s& Z1 r( v8 W7 t某些gcc编译器版本(如3.2.3)会报告“warning: #pragma once is obsolete”的警告，而其他较老版本的编译器可能会报错。但随着gcc 3.4的发布，#pragma once中的一些问题(主要与符号链接和硬链接有关)得以解决，#pragma once命令也标记为“未废弃”。
. L+ X* Z3 y. J, q1 D, g还有种写法同时使用#pragma once和header guard编写“可移植性”代码，以利用编译器可能支持的#pragma once优化。如下：5 s3 R2 N8 W! Y3 ]" j
#pragma once
#ifndef _PRJ_DIR_FILE_H% k. y$ B) g4 n" _) X1 A
#define _PRJ_DIR_FILE_H0 r0 r' N0 a# b
# t" X8 ^! s* M# d9 R% [% a) i/ g4 Z7 N0 m6 W
//<头文件内容>
) K+ J. i# `. N) _- j6 ]
#endif


0 A( K% m* m3 e$ r3 M+ g8 @* K
该法似乎兼有两者的优点。但既然使用#ifndef就有宏名重名的风险，也无法避免不支持#pragma once的编译器告警或报错，故混用两种方法似乎不能带来更多的好处，反倒让不熟悉的人感到困惑。+ ^& l7 b( M, Y% s! L9 o$ M
注意，如果使用header guard，理论上可在代码任何地方判断当前是否已经包含某个头文件。但应避免通过该判断来改变后续代码的逻辑走向！
这种做法将使程序依赖于头文件的包含顺序，极不可取。若需要实现“若当前包含HeaderA.h，才加入StructB结构”，可对StructB结构创建HeaderB.h头文件，在HeaderA.h中包含HeaderB.h。
" q7 P1 i7 S+ ?8 c  ?4 Y" ~( M* T

「【注3】extern "C"」

, y8 [) v, R( c6 J2 y  w) h
C++语言在编译时为实现函数重载，会结合函数名、参数数目及类型信息而生成一个中间函数名。; L2 |2 w7 @1 t7 G* o1 X
例如，C++中函数void foo(int x, float y)编译后在符号库中生成的名字为_foo_int_float(不同编译器可能生成不同函数名，但均采用相同机制，生成的新名字称为”mangled name”)；而该函数被C编译器编译后在符号库中的名字为_foo。
C语言中不支持extern "C"声明，在.c文件中包含extern "C"时会出现编译语法错误。
当然编译器也可以为其他语言提供链接说明。例如：extern "FORTRAN"、extern "Ada"等。

「【注4】声明(declaration)与定义(definition)」

全局变量或函数可(在多个编译单元中)有多处声明，但只允许定义一次。全局变量定义时分配空间并赋初始值(如果有)；函数定义时提供函数体内容。
) \6 f! g7 {: `6 [  x- g! {  z! ~声明：
extern int iGlobal;/ o$ B, ~2 I3 x) h* `% z
extern int func(); 或int func();* g. u$ n) v7 j4 z
$ k* O( K% X1 Z$ Z' m3 s% I! ]9 U5 X0 I6 G8 N
: g( q' X( L: N$ y0 v定义：1 w5 [  \  `% U: U' E8 C6 r2 ]
int iGlobal = 0; 或int iGlobal;
int func ()
7 s( i9 U; R3 Q( s: m1 i. I{' u; R8 K7 l* H
; T8 |; v+ B: D% d# a7 x0 a    return 1;! u; o: J* y4 ]- o# P$ ~
2 m. P+ R( q: a  n}" @) o( {. W  v7 ^& M/ s
" m# b  I% {5 y9 a, {+ C: O* Y; f& w9 L2 l: H


! H! l/ G' g% ?2 g  y3 {+ s在多个源文件中共享变量或函数时，需确保定义和声明的一致性。通常在某个相关的源文件中定义，然后在头文件中进行外部声明。需要使用时包含相应的头文件即可。定义变量的源文件也应包含该头文件，以便编译器检查定义和声明的一致性。9 M& b/ N  @0 B3 e  O% h
6 v- k8 c4 R& Q6 S$ l; V* A该规则可提供高度的可移植性：它与ANSI/ISO C标准一致，同时也兼顾大多数ANSI前的编译器和链接器。(Unix编译器和链接器常使用允许多重定义的“通用模式”，只要保证最多对一处定义进行初始化即可。
该方式被ANSI C标准称为一种“通用扩展”)。某些很老的系统可能要求显式初始化以区别定义和外部声明。3 ]$ W( @7 R' h% C
通用扩展在《深入理解计算机系统》中解释为：多重定义的符号只允许最多一个强符号。函数和定义时已初始化的全局变量是强符号；未初始化的全局变量是弱符号。Unix链接器使用以下规则来处理多重定义的符号：4 k% `% o) b, g. O
' ]5 F- K5 X8 L规则一：不允许有多个强符号。在被多个源文件包含的头文件内定义的全局变量会被定义多次(预处理阶段会将头文件内容展开在源文件中)，若在定义时显式地赋值(初始化)，则会违反此规则。8 f* c( w8 k: ?3 [
规则二：若存在一个强符号和多个弱符号，则选择强符号。
: {+ }- [7 f9 t$ `规则三：若存在多个弱符号，则从这些弱符号中任选一个。
3 J, i' y3 o  \6 R# P$ e5 I: g当不同文件内定义同名(即便类型和含义不同)的全局变量时，该变量共享同一块内存(地址相同)。若变量定义时均初始化，则会产生重定义(multiple definition)的链接错误；若某处变量定义时未初始化，则无链接错误，仅在因类型不同而大小不同时可能产生符号大小变化(size of symbol `XXX' changed)的编译警告。' w8 K1 g2 t8 x/ X3 W/ _! j5 f
在最坏情况下，编译链接正常，但不同文件对同名全局变量读写时相互影响，引发非常诡异的问题。这种风险在使用无法接触源码的第三方库时尤为突出。! E: O) e; S  U- z% `+ @# s' a. Z
# A" @. T$ l+ y. E+ h& l  w因此，应尽量避免使用全局变量。若确有必要，应采用静态全局变量(无强弱之分，且不会和其他全局符号产生冲突)，并封装访问函数供外部文件调用。
4 _, a& ^" f  ?4 d* X$ [* D" b3 ?) p8 j

「【注5】前向声明(forward declaration)」

/ @  ^6 Z0 V" K: Y$ Z
4 S  c* n( ?! d+ t& q4 o( [结构体类型S在声明之后定义之前是一个不完全类型(incomplete type)，即已知S是一个类型，但不知道包含哪些成员。
+ n" \  Q& A# w( ^  O1 r6 u不完全类型只能用于定义指向该类型的指针，或声明使用该类型作为形参指针类型或返回指针类型的函数。指针类型对编译器而言大小固定(如32位机上为四字节)，不会出现编译错误。
假设先后定义两个结构A和B，且两个结构需要互相引用。在定义A时B还没有定义，则要引用B就需要前向声明结构B(struct B;)。示例如下：
( H5 r8 o4 e% |# r1 ~typedef BOOL (*func)(const DefStruct *ptStrt);6 n3 A' n. _# M( [" G  u, u. c' m
- u) q. a# U! ~: D* Y
typedef struct DefStruct_t+ d4 J" j" S3 i, f
{2 \& X- Z& m* c0 @+ P  t( {0 `
* J5 V6 G: E, d/ i2 G* R    int i;
  g& w5 K/ V" H8 B! S7 J    func f;& e6 ?- S; c$ P7 i# i9 j& ]% R
}DefStruct;
+ l+ h: u, U- s) C
% {+ }- s. A9 \% g. g+ c) E# @9 Q; s8 O( I. N/ k/ f
; K' z3 ?. K% `: {
3 h- V- o: U' l  D1 |0 x如上在DefStruct中使用回调函数func声明，这样交叉引用必然编译报错。进行前向声明即可：( U$ g, u. P5 N2 p8 @  ^
typedef struct DefStruct_t DefStruct;
typedef BOOL (*func)(const DefStruct *ptStrt);
$ G9 k2 K* E/ R7 E# G4 f
struct DefStruct_t. b( O$ D: s4 F8 V& y3 K
  I0 L/ Y( n1 O$ h& R{" O2 J8 |0 T7 [! t; J
6 r2 _, O, A  H+ s# v9 t    int i;& ?4 v7 t1 k) Z
    func f;! W8 _. \. s( ^: N
& V. p* c; n1 h9 p! o};

5 k0 ^7 p0 [' H7 o注意，在前向声明和具体定义之间涉及标识符(变量、结构、函数等)实现细节的使用都是非法的。若函数被前向声明但未被调用，则编译和运行正常；若前向声明函数被调用但未被定义，则编译正常但链接报错(undefined reference)。将具体定义放在源文件中可部分避免该问题。