c语言中头文件书写格式

C语言书写规范指南第1章文件结构每个C程序通常分为两个文件。

一个文件用于保存程序的声明（declaration），称为头文件。

另一个文件用于保存程序的实现（implementation），称为定义（definition）文件。

C程序的头文件以“.h”为后缀，C程序的定义文件以“.c”为后缀。

1.1版权和版本的声明版权和版本的声明位于头文件和定义文件的开头（参见示例1-1），主要内容有：（1）版权信息。

（2）文件名称，标识符，摘要。

（3）当前版本号，作者/修改者，完成日期。

（4）版本历史信息。

/**Copyright(c)2001,吉林大学物理学院无线电*Allrightsreserved.**文件名称：filename.h*文件标识：*摘要：简要描述本文件的内容**当前版本：1.1*作者：输入作者（或修改者）名字*完成日期：2007年7月20日**取代版本：1.0*原作者：输入原作者（或修改者）名字*完成日期：2007年5月10日*/示例1-1版权和版本的声明1.2头文件的结构头文件由三部分内容组成：（1）头文件开头处的版权和版本声明（参见示例1-1）。

（2）预处理块。

（3）函数和类结构声明等。

假设头文件名称为SCL_SPI.h，头文件的结构参见示例1-2。

【规则1-2-1】为了防止头文件被重复引用，应当用#ifndef/#define/#endif结构产生预处理块。

【规则1-2-2】用#include <filename.h>格式来引用标准库的头文件（编译器将从标准库目录开始搜索）。

【规则1-2-3】用#include “filename.h”格式来引用非标准库的头文件（编译器将从用户的工作目录开始搜索）。

【规则1-2-4】#include 后面使用TAB键控制排版。

【规则1-2-5】头文件中只存放“声明”而不存放“定义”【规则1-2-6】全局变量在头文件中声明,在.c文件中定义.h extern in tvalue; 声明。

C语言的头文件常用于声明函数、变量、宏和结构体等的定义，以便在多个源文件中共享和重用这些声明。

以下是C语言头文件的一般写法：
c
#ifndef HEADER_NAME_H
#define HEADER_NAME_H
// 在这里写下头文件的内容
#endif /* HEADER_NAME_H */
头文件的命名通常使用全大写字母，可以根据需要选择有意义的名称。

头文件中应该包含以下内容：
防止多重包含：使用条件编译指令#ifndef、#define 和#endif，以避免头文件被重复包含。

函数声明：声明函数的原型，例如int add(int a, int b);。

变量声明：声明变量的外部链接性，例如extern int globalVariable;。

宏定义：定义常量、宏函数和条件编译宏等，例如#define PI 3.14159。

结构体定义：定义结构体类型，例如struct Person { char name[20]; int age; };。

请注意以下几点：
头文件中通常只包含声明，而不包含具体的实现代码。

实现代码应该在对应的源文件中编写。

头文件应该包含所需的其他头文件，以确保所有依赖关系得到满足。

在编写头文件时，应使用预处理指令#ifdef 和#ifndef 来避免重复定义和冲突。

头文件应该尽量精简和模块化，只包含与该头文件相关的声明。

在头文件中避免定义全局变量，因为头文件可能会被多个源文件包含，这样会导致变量的重复定义。

正确编写和组织头文件可以提高代码的可读性、可维护性和重用性，推荐遵循良好的编码规范和项目约定。

C程序采用模块化的编程思想，需合理地将一个很大的软件划分为一系列功能独立的部分合作完成系统的需求，在模块的划分上主要依据功能。

模块由头文件和实现文件组成，对头文件和实现文件的正确使用方法是：规则1头文件(.h)中是对于该模块接口的声明，接口包括该模块提供给其它模块调用的外部函数及外部全局变量，对这些变量和函数都需在.h中文件中冠以extern关键字声明；规则2 模块内的函数和全局变量需在.c文件开头冠以static关键字声明；规则3 永远不要在.h文件中定义变量；许多程序员对定义变量和声明变量混淆不清，定义变量和声明变量的区别在于定义会产生内存分配的操作，是汇编阶段的概念；而声明则只是告诉包含该声明的模块在连接阶段从其它模块寻找外部函数和变量。

规则4 如果要用其它模块定义的变量和函数，直接包含其头文件即可。

许多程序员喜欢这样做，当他们要访问其它模块定义的变量时，他们在本模块文件开头添加这样的语句：extern int externVar;抛弃这种做法吧，只要头文件按规则1完成，某模块要访问其它模块中定义的全局变量时，只要包含该模块的头文件即可。

共享变量声明就像在函数间共享变量的方式一样，变量可以在文件中共享。

为了共享函数，要把函数的定义放在一个源文件中，然后在需要调用此函数的其他文件中放置声明。

共享变量的方法和此方式非常类似。

在此之前，不需要区别变量的声明和它的定义。

为了声明变量i，写成如下形式：int i;这样不仅声明i是int型的变量，而且也对i进行了定义，从而使编译器为i留出了空间。

为了声明没有定义的变量i，需要在变量声明的开始处放置关键字extern：extern int i;extern提示编译器变量i是在程序中的其他位置定义的（大多数可能是在不同的源文件中），因此不需要为i分配空间。

顺便说一句，extern可以用于所有类型的变量。

在数组的声明中使用extern时，可以忽略数组的长度：extern int a[];因为此刻编译器不用为数组a分配空间，所以也就不需要知道数组a的长度了。

关于C语言编程书写规范的规则和建议一、头文件♦头文件由三部分内容组成：1、头文件开头处的版权和版本声明。

2、预处理块。

3、函数和类结构声明等。

♦【规则】为了防止头文件被重复引用，应当用ifndef/define/endif结构产生预处理块。

♦【规则】用#include <filename.h> 格式来引用标准库的头文件（编译器将从标准库目录开始搜索）.♦【规则】用#include “filename.h”格式来引用非标准库的头文件（编译器将从用户的工作目录开始搜索）♦【建议】头文件中只存放“声明”而不存放“定义”♦【建议】不提倡使用全局变量，尽量不要在头文件中出现象extern int value 这类声明。

二、程序的版式空行♦【规则】在每个类声明之后、每个函数定义结束之后都要加空行。

♦【规则】在一个函数体内，逻揖上密切相关的语句之间不加空行，其它地方应加空行分隔。

代码行♦【规则】一行代码只做一件事情，如只定义一个变量，或只写一条语句。

这样的代码容易阅读，并且方便于写注释。

♦【规则】if、for、while、do等语句自占一行，执行语句不得紧跟其后。

不论执行语句有多少都要加{}。

这样可以防止书写失误。

♦【建议】尽可能在定义变量的同时初始化该变量（就近原则）代码行内的空格♦【规则】关键字之后要留空格。

象const、virtual、inline、case 等关键字之后至少要留一个空格，否则无法辨析关键字。

象if、for、while等关键字之后应留一个空格再跟左括号‘（’，以突出关键字。

♦【规则】函数名之后不要留空格，紧跟左括号‘（’，以与关键字区别。

♦【规则】‘（’向后紧跟，‘）’、‘，’、‘;’向前紧跟，紧跟处不留空格。

♦【规则】‘，’之后要留空格，如Function(x, y, z)。

如果‘;’不是一行的结束符号，其后要留空格。

♦【规则】赋值操作符、比较操作符、算术操作符、逻辑操作符、位域操作符，如“=”、“+=”“>=”、“<=”、“+”、“*”、“%”、“&&”、“||”、“<<”,“^”等二元操作符的前后应当加空格。

C语言的开头格式通常包括头文件和main函数，具体如下：
1. 头文件：#include <stdio.h>
这是一个预处理指令，它指示编译器在编译过程中引入标准输入输出库（stdio.h），以便后续的程序可以使用标准输入输出函数，例如printf()和scanf()等。

2. main函数：int main()
这是C语言程序的入口函数，程序将从这里开始执行。

main函数必须返回一个整数值，通常情况下，返回值为0表示程序正常结束，非0值则表示程序异常结束。

在main函数中可以编写程序代码，完成特定的任务。

例如，可以编写代码来计算两个数的和、输出一段文本、读取用户输入等等。

文件包含与头文件的写法很多人对C语言中的“文件包含”都不陌生了，文件包含处理在程序开发中会给我们的模块化程序设计带来很大的好处，通过文件包含的方法把程序中的各个功能模块联系起来是模块化程序设计中的一种非常有利的手段。

文件包含处理是指在一个源文件中，通过文件包含命令将另一个源文件的内容全部包含在此文件中。

在源文件编译时，连同被包含进来的文件一同编译，生成目标目标文件。

很多人再初学时都会对这个很晕，怎么写文件件? 怎么包含才能避免重定义? 等等问题。

其实这个只要了解了文件包含的基本处理方法就可以对文件包含有一个很好的理解与应用了，下来我们一起来看一下：文件包含的处理方法：首先大家需要清楚：(1) 处理时间：文件包含也是以"#"开头来写的(#include ), 那么它就是写给预处理器来看了, 也就是说文件包含是会在编译预处理阶段进行处理的。

(2) 处理方法：在预处理阶段，系统自动对#include命令进行处理，具体做法是:降包含文件的内容复制到包含语句(#include )处，得到新的文件，然后再对这个新的文件进行编译。

抓住这两点，那么这个东东就没有什么难的了。

一般情况下文件包含分为两种：包含.h文件和包含.c文件1. 当然对于这两情况也都是按照上面说的方法来处理的。

呵呵，这个肯定是没得说的.2. 包含.c文件和编译多文件程序是不同的。

多文件程序: 是在源文件编译时把多个文件进行编译、连接在一起生成一个可执行文件。

包含.c文件:按照我们上边的说法则是把多个文件合并为一个文件进行编译。

接下来通过例子看一下：(1)包含.c文件:1://file1: main.c2: #include3: #include "fun.c"4:int main()5: {6:int a=5,b=19;7: c = a;8:sun(a,b);9:printf("c=%d\n",c);10:return 0;11: }12: //end of file11://file2: fun.c2:int c=0;3:void sun(int a, int b)4: {5: printf("a+b=%d\n",a+b);6: c=0;7: printf("c=%d\n",c);8: }9://end of file210:这个例子是采用包含.c文件的方法实现的。

C51中头文件的写法一、头文件位置#include ; 优先在系统默认路径查找头文件#include&ldquo;xxx.h&rdquo;有现在项目路径查找头文件二、#ifndef和#endif通常形式为#ifndef _xxxx_h_#define _xxxx_h_.........(头文件具体内容)#endif这样的写法表示，如果_xxxx_h_还没有被定义，那么头文件内容将被执行，如果已经定义过了，那么头文件内容就不执行了。

作用在于，如果某头文件被不同c文件同时调用，那么里面的内容不至于因为重复定义而出错，因为不管调用几次头文件，其内容只有在第一次出现时被执行，同时定义一个_xxxx_h_，以后再次调用时，头文件内容被忽略。

三、函数和宏假设有如下文件 main.caaa.caaa.h其中,，aaa.c里面有一个宏X，一个函数Y，且函数Y 中使用了Xaaa.h里面申明了函数Ymain.c里包含了aaa.h文件，调用了函数Y，但没有定义宏X那么，编译时不会出错，这表示，函数Y中出现宏X 时，它会在自身所在的c文件，即aaa.c里面查找宏变化1：如上情况不变，但是在main.c里面将整个函数Y重新写一遍编译出错，提示 &ldquo;error C202: 'X': undefined identifier&rdquo;说明此时函数Y在main.c文件中找不到宏X，因此提示为未定义的符号变化2：将aaa.c中的宏剪切到main.c，其余情况不变编译出错，同样提示&ldquo;error C202: 'X': undefined identifier&rdquo;结论：函数中如果出现宏，那么该函数能且只能在其自身所在的c文件中查找该宏，如果二者不在同个c 文件，必然出错。

C语言文件包含与头文件写法C语言文件包含的处理方法：（1）处理时间：（#include）预处理阶段（2）处理方法：在预处理阶段，系统自动对#include命令进行处理。

具体做法是：将包含文件的内容复制到包含语句（#include）处，得到新的文件，然后对新的文件进行编译。

一般情况下包含文件分为两种：包含.h 文件和包含.c文件包含.c文件的编译和编译多文件程序(包含.h的文件就是如此) 是不同的。

（1）包含.c文件[cpp] view plaincopy/*file1:main.c */#include <stdio.h>//#include "fun.c"int main(){int a = 5, b = 19;c = a;sun(a, b);printf("\r\n c = %d\r\n", c);return 0;}/*end of file1*/[cpp] view plaincopy[cpp] view plaincopy/*file2: fun.c*/int c = 0;void sun(int a, int b){printf("\r\n a + b = %d\r\n", a+b);[cpp] view plaincopyc = 0;printf("\r\nc = %d\r\n", c);}/*end of file2*/编译时，直接去编译main.c文件，预处理器会先把fun.c文件的内容复制到main.c中，然后在对新的main.c进行编译只需在执行编译命令gccmain.c -o main可以通过以下命令查看预处理的结果：gcc-Emain.c -o main.cpp其实就是将fun.c文件的内容添加到了main函数之前，然后对新的文件进行编译，最终生成可执行程序。

（2）编译多文件程序，对每个.c分别编译生成.o,最后链接生成可执行文件，需要注意的是一定要防止变量的重定义。

C和传统C++的头文件写法:#include <assert.h> //设定插入点#include <ctype.h> //字符处理#include <errno.h> //定义错误码#include <float.h> //浮点数处理#include <fstream.h> //文件输入／输出#include <iomanip.h> //参数化输入／输出#include <iostream.h> //数据流输入／输出#include <limits.h> //定义各种数据类型最值常量#include <locale.h> //定义本地化函数#include <math.h> //定义数学函数#include <stdio.h> //定义输入／输出函数#include <stdlib.h> //定义杂项函数及内存分配函数#include <string.h> //字符串处理#include <strstrea.h> //基于数组的输入／输出#include <time.h> //定义关于时间的函数#include <wchar.h> //宽字符处理及输入／输出#include <wctype.h> //宽字符分类/******************************/标准C++的写法: （同上的不再注释）#include <algorithm> //STL 通用算法#include <bitset> //STL 位集容器#include <cctype>#include <cerrno>#include <clocale>#include <cmath>#include <complex> //复数类#include <cstdio>#include <cstdlib>#include <cstring>#include <ctime>#include <deque> //STL 双端队列容器#include <exception> //异常处理类#include <fstream>#include <functional> //STL 定义运算函数（代替运算符）#include <limits>#include <list> //STL 线性列表容器#include <map> //STL 映射容器#include <iomanip>#include <ios> //基本输入／输出支持#include <iosfwd> //输入／输出系统使用的前置声明#include <iostream>#include <istream> //基本输入流#include <ostream> //基本输出流#include <queue> //STL 队列容器#include <set> //STL 集合容器#include <sstream> //基于字符串的流#include <stack> //STL 堆栈容器#include <stdexcept> //标准异常类#include <streambuf> //底层输入／输出支持#include <string> //字符串类#include <utility> //STL 通用模板类#include <vector> //STL 动态数组容器#include <cwchar>#include <cwctype>using namespace std;/******************************/C99 增加#include <complex.h> //复数处理#include <fenv.h> //浮点环境#include <inttypes.h> //整数格式转换#include <stdbool.h> //布尔环境#include <stdint.h> //整型环境#include <tgmath.h> //通用类型数学宏/******************************/一般一个C++的老的带“.h”扩展名的库文件，比如iostream.h，在新标准后的标准库中都有一个不带“.h”扩展名的相对应，区别除了后者的好多改进之外，还有一点就是后者的东东都塞进了“std”名字空间中。

#ifndef __digital_h__#define __digital_h__#ifndef __cplusplusextern "C"{#endif#ifdef __cplusplus}#eddif#endifc语言中的.h头文件的格式自定义头文件通常放在使用该头文件的源文件所在的目录中，并使用#include "MyHead.h" 来包含。

头文件是不编译的，因为C语言编译过程之前有个预编译过程。

在这个过程中用头文件中的内容替换源文件中“#include”命令，所以在编译器看来，没有头文件，只有源文件。

预编译过程还包括条件编译。

头文件为了防止被重复包含，通常的格式是：#ifndef _MYHEAD_H_#define _MYHEAD_H_（这里是头文件的内容）#endif预处理：预编译处理是指在编译系统对文件进行编译---词法分析、语法分析、代码生成及优化之前，对一些特殊的编译语句先进行处理，然后将处理结果与源程序一起编译，生成目标文件。

条件编译：条件编译指令将决定那些代码被编译，而哪些是不被编译的。

可以根据表达式的值或者某个特定的宏是否被定义来确定编译条件。

#endif用于结束条件编译，编译时与前面最近的#if #ifdef或#ifndef作为一对，经常一起使用，编译两者之间的部分程序段。

下面是一个头文件memdev.h的例子#ifndef _MEMDEV_H_#define _MEMDEV_H_#include<linux/ioctl.h>#ifndef MEMDEV_MAJOR#define MEMDEV_MAJOR 0#endif#ifndef MEMDEV_NR_DEVS#define MEMDEV_NR_DEVS 2#endif#ifndef MEMDEV_SIZE#define MEMDEV_SIZE 4096#endifstruct mem_dev{char *data;unsigned long size;};#define MEMDEV_IOC_MAGIC 'k'#define MEMDEV_IOCPRINT _IO(MEMDEV_IOC_MAGIC,1)#define MEMDEV_IOCGETDATA _IOR(MEMDEV_IOC_MAGIC,2,int) #define MEMDEV_IOCSETDATA _IOW(MEMDEV_IOC_MAGIC,3,int) #define MEMDEV_IOC_MAXNR 3#endif。

C语⾔头⽂件源⽂件C语⾔头⽂件源⽂件1、头⽂件与源⽂件头⽂件⽤于声明接⼝函数，格式如下如创建test.h#ifndef _TEST_H_#define _TEST_H_/*接⼝函数的申明*/#endif#ifndef _TEST_H_#define _TEST_Hint sum(int x, int y);void swap(int *x, int *y);int max(int x, int y);#endif源⽂件⽤于接⼝函数的实现，源⽂件中只写接⼝函数的实现不能写main()函数#include <stdio.h>#include "test.h"int sum(int x, int y){return x+y;}void swap(int *x, int *y){int tmp;tmp = *x;*x = *y;*y = tmp;}int max(int x, int y){return (x>y)? x : y;}2、⽤户⽂件头⽂件和源⽂件⼀般是标准库⽂件或者⾃定义的库⽂件，⽤户⽂件则是我们⾃⼰写的⽂件，我们需要在⽤户⽂件中使⽤库⽂件或函数，就要包含所需的头⽂件#include <stdio.h>#include "test.h"int main(){int a = 1, b = 2;swap(&a, &b);printf("sum(%d,%d)=%d\n", a, b, sum(a, b));printf("a=%d, b=%d\n", a, b);printf("max(%d,%d)=%d\n", a, b, max(a, b));return0;}3、多⽂件编译当我们使⽤的时候，如果只编译main.c（gcc main.c）就会报错原因是在test.h中找不到函数的实现，所以在编译时要将源⽂件test.c和main.c⼀起编译（gcc main.c test.c），这样就不会报错4、makefile和shell脚本当我们包含的头⽂件特别多，在编译时就要编译很多源⽂件（gcc main.c test1.c test2.c test3.c test4.c ... testn.c），这样就会⾮常长，所以我们可以将命令⾏写到脚本⾥⾯进⾏批处理（1）shell脚本创建⼀个build.sh的脚本⽂件，然后将需要编译的命令⾏写到脚本⽂件⾥，编译时输⼊命令 sh build.sh就完成了编译（2）makefile（待续。

如何在Ｃ语言中自已写头文件标签：Ｃ语言头文件分类：专业文献 2008-07-23 16:13一些初学C语言的人，不知道头文件（*.h文件）原来还可以自己写的。

只知道调用系统库函数时，要使用#include语句将某些头文件包含进去。

其实，头文件跟.C文件一样，是可以自己写的。

头文件是一种文本文件，使用文本编辑器将代码编写好之后，以扩展名.h 保存就行了。

头文件中一般放一些重复使用的代码，例如函数声明，变量声明，常数定义，宏的定义等等。

当使用#include语句将头文件引用时，相当于将头文件中所有内容，复制到#include处。

为了避免因为重复引用而导致的编译错误，头文件常具有#ifndef LABEL#define LABEL//代码部分#endif的格式。

其中，LABEL为一个唯一的标号，命名规则跟变量的命名规则一样。

常根据它所在的头文件名来命名，例如，如果头文件的文件名叫做hardware.h，那么可以这样使用：#ifndef __HARDWARE_H__#define __HARDWARE_H__//代码部分#endif这样写的意思就是，如果没有定义__HARDWARE_H__，则定义__HARDWARE_H__，并编译下面的代码部分，直到遇到#endif。

这样，当重复引用时，由于__HARDWARE_H__已经被定义，则下面的代码部分就不会被编译了，这样就避免了重复定义。

另外一个地方就是使用include时，使用引号与尖括号的意思是不一样的。

使用引号(“”)时，首先搜索工程文件所在目录，然后再搜索编译器头文件所在目录。

而使用尖括号(<>)时，刚好是相反的搜索顺序。

假设我们有两个文件名一样的头文件hardware.h，但内容却是不一样的。

一个保存在编译器指定的头文件目录下，我们把它叫做文件I；另一个则保存在当前工程的目录下，我们把它叫做文件II。

如果我们使用的是#include<hardware.h>，则我们引用到的是文件I。

编写自己的C语言头文件一些初学C语言的人，不知道头文件（*.h文件）原来还可以自己写的。

只知道调用系统库函数时，要使用#include语句将某些头文件包含进去。

其实，头文件跟.C文件一样，是可以自己写的。

头文件是一种文本文件，使用文本编辑器将代码编写好之后，以扩展名.h保存就行了。

头文件中一般放一些重复使用的代码，例如函数声明，变量声明，常数定义，宏的定义等等。

当使用#include语句将头文件引用时，相当于将头文件中所有内容，复制到#include 处。

为了避免因为重复引用而导致的编译错误，头文件常具有#ifndef LABEL#define LABEL//代码部分#endif的格式。

其中，LABEL为一个唯一的标号，命名规则跟变量的命名规则一样。

常根据它所在的头文件名来命名，例如，如果头文件的文件名叫做hardware.h，那么可以这样使用：#ifndef__HARDWARE_H__#define__HARDWARE_H__//代码部分#endif这样写的意思就是，如果没有定义__HARDWARE_H__，则定义__HARDWARE_H__，并编译下面的代码部分，直到遇到#endif。

这样，当重复引用时，由于__HARDWARE_H__已经被定义，则下面的代码部分就不会被编译了，这样就避免了重复定义。

另外一个地方就是使用include时，使用引号与尖括号的意思是不一样的。

使用引号(“”)时，首先搜索工程文件所在目录，然后再搜索编译器头文件所在目录。

而使用尖括号(<>)时，刚好是相反的搜索顺序。

假设我们有两个文件名一样的头文件hardware.h，但内容却是不一样的。

一个保存在编译器指定的头文件目录下，我们把它叫做文件I；另一个则保存在当前工程的目录下，我们把它叫做文件II。

如果我们使用的是#include<hardware.h>，则我们引用到的是文件I。

如果我们使用的是#include“hardware.h”，则我们引用的将是文件II。

C语言书写规指南第1章文件结构每个C程序通常分为两个文件。

一个文件用于保存程序的声明（declaration），称为头文件。

另一个文件用于保存程序的实现（implementation），称为定义（definition）文件。

C程序的头文件以“.h”为后缀，C程序的定义文件以“.c”为后缀。

1.1和版本的声明和版本的声明位于头文件和定义文件的开头（参见示例1-1），主要容有：（1）信息。

（2）文件名称，标识符，摘要。

（3）当前版本号，作者/修改者，完成日期。

（4）版本历史信息。

/**Copyright(c)2001,大学物理学院无线电*Allrightsreserved.**文件名称：filename.h*文件标识：*摘要：简要描述本文件的容**当前版本：1.1*作者：输入作者（或修改者）名字*完成日期：2007年7月20日**取代版本：1.0*原作者：输入原作者（或修改者）名字*完成日期：2007年5月10日*/示例1-1和版本的声明1.2头文件的结构头文件由三部分容组成：（1）头文件开头处的和版本声明（参见示例1-1）。

（2）预处理块。

（3）函数和类结构声明等。

假设头文件名称为SCL_SPI.h，头文件的结构参见示例1-2。

【规则1-2-1】为了防止头文件被重复引用，应当用#ifndef/#define/#endif结构产生预处理块。

【规则1-2-2】用#include <filename.h>格式来引用标准库的头文件（编译器将从标准库目录开始搜索）。

【规则1-2-3】用#include “filename.h”格式来引用非标准库的头文件（编译器将从用户的工作目录开始搜索）。

【规则1-2-4】#include 后面使用TAB键控制排版。

【规则1-2-5】头文件中只存放“声明”而不存放“定义”【规则1-2-6】全局变量在头文件中声明,在.c文件中定义.h extern in tvalue; 声明。

头文件一般由三部分内容组成：(1)头文件开头处的版权和版本声明；(2)预处理块；(3)函数和类结构声明等。

例如：（以下将提取头文件SeqList.h部分内容进行说明，紫色部分为头文件原文）/*顺序存储结构头文件版本：？？版权：？？*/（在头文件的开头进行注释，以声明版权和版本）#define MaxSize 100 （在定义功能函数之前的定义都称为预处理块，意思即为：在实现功能函数之前必须预先处理的模块。

主函数中也有预处理块，例如调用头文件#include<stdio.h>，#define……等等。

和头文件是一样的。

这里的#define MaxSize 100 就是一个预处理块。

）typedef struct（类结构声明，即定义结构体等）{DataType list[MaxSize];int size;}SeqList;void ListInitiate(SeqList *L) /*初始化顺序表L*/（函数声明，即定义实现某种功能的功能函数。

这里定义的函数ListInitiate()为初始化顺序功能）{L->size=0; /*定义初始数据元素的个数*/}int ListLength(SeqList L) /*返回顺序表L的当前数据元素个数*/{return L.size;}在头文件中，用ifndef/define/endif结构产生预处理块，用#include 格式来引用库的头文件。

头文件的这种结构，是利用C语言进行开发软件所通常具备的，属于公有知识。

头文件是用户应用程序和函数库之间的桥梁和纽带。

在整个软件中，头文件不是最重要的部分，但它是C语言家族中不可缺少的组成部分。

做一个不算很恰当的比喻，头文件就像是一本书中的目录，读者(用户程序)通过目录，可以很方便就查阅其需要的内容(函数库)。

在一本书中，目录固然重要，但绝对不是一本书的核心的、最重要的部分。