研学论坛 - 【分享】C,C++使用头文件的原因及注意事项#158372
[CC++]编程规范一：头文件篇
![[CC++]编程规范一：头文件篇](https://img.taocdn.com/s3/m/56a4e85d2a160b4e767f5acfa1c7aa00b42a9d5d.png)
[CC++]编程规范⼀：头⽂件篇⼀般来说，每⼀个.cc或者.cpp⽂件对应⼀个头⽂件(.h⽂件)，当然，也有例外，例如⼀些测试单元或者main⽂件，头⽂件的⼀些规范可以令代码可读性、程序的性能等⼤为改观，所以还是要注意头⽂件的规范问题。
⼀、#define保护所有头⽂件为了防⽌⽂件被多重包含(multiple inclusion)，⼀般就需要#define保护。
#define保护的格式如下：<PROJECT>_<PATH>_<FILE>_H_例如：#ifndef FOO_BAR_BARZ_H_#define FOO_BAR_BARZ_H_...#endif //FOO_BAR_BARZ_H_这个是⽐较⽼的⼀个做法了，所以很多编译器基本都是可以兼容的，但是还有另⼀个语句也是可以起到相同作⽤，但是⼀些太⽼的编译器据说⽤不了的(但是我好像没遇到过)，VS下好像默认新建⼀个类的头⽂件就会⽤这个新的:#program once这⼀种相对于第⼀种的好处是，不通过#define⼀个变量来起到防⽌重复包含，所以，不存在重复变量的问题，#define后⾯的变量在同⼀个⼯程⾥是不能重复的，重复的话是只认⼀个的，就可能导致另⼀个⽂件编译的时候被排除。
⼆、头⽂件依赖在头⽂件中减少包含其他头⽂件，改⽤前置声明(forward declarations)，理由是：头⽂件被包含的同时会引⼊⼀项新的依赖(dependency)，只要头⽂件被修改，代码就要重新编译，如果你的头⽂件包含了其它头⽂件，这些头⽂件的任何改动都将导致那些包含了你的头⽂件的代码重新编译。
使⽤前置声明就是在头⽂件中添加：class Foo;然后在对应的源⽂件中包含对应的头⽂件#include <Foo.h>可以这么做的⼏种情况：1)、将数据声明为指针(Foo*)或者引⽤(Foo&)；2)、参数、返回值为Foo的函数只声明不定义；3)、静态数据成员可以被声明为Foo，因为静态数据成员的定义在类定义之外；但是，如果你的类是Foo的⼦类或者包含类型为Foo的⾮静态成员数据，则必须包含头⽂件。
C语言中头文件和cpp文件解析
C语⾔中头⽂件和cpp⽂件解析回到cpp⽂件与头⽂件各写什么内容的话题上：理论上来说cpp⽂件与头⽂件⾥的内容，只要是C语⾔所⽀持的，⽆论写什么都可以的，⽐如你在头⽂件中写函数体实现，任何⼀个cpp⽂件包含此头⽂件就可以将这个函数编译成⽬标⽂件的⼀部分（编译是以cpp⽂件为单位的，如果不在任何cpp⽂件中包含此头⽂件的话，这段代码就形同虚设），你可以在cpp⽂件中进⾏函数声明、变量声明、结构体声明，这也不成问题那为何⼀定要分成头⽂件与cpp⽂件呢？⼜为何⼀般都在头件中进⾏函数、变量声明，宏声明，结构体声明呢？⽽在cpp⽂件中去进⾏变量定义，函数实现呢？？原因如下： 1.如果在头⽂件中实现⼀个函数体，那么如果在多个cpp⽂件中引⽤它，⽽且⼜同时编译多个cpp⽂件，将其⽣成的⽬标⽂件连接成⼀个可执⾏⽂件，在每个引⽤此头⽂件的cpp⽂件所⽣成的⽬标⽂件中，都有⼀份这个函数的代码，如果这段函数⼜没有定义成局部函数，那么在连接时，就会发现多个相同的函数，就会报错，函数重复定义。
2.如果在头⽂件中定义全局变量，势必会对此全局变量赋初值，那么在多个引⽤此头⽂件的cpp⽂件中同样存在相同变量名的拷贝，关键是此变量被赋了初值，所以编译器就会将此变量放⼊DATA段，最终在连接阶段，会在DATA段中存在多个相同的变量，它⽆法将这些变量统⼀成⼀个变量，统⼀变量的意思也就是仅为此变量分配⼀个空间，⽽不是多份空间。
但是对于声明⼀个变量，这个变量在头⽂件没有赋初值，编译器就会将之放⼊BSS段，连接器会对BSS段的多个同名变量仅分配⼀个存储空间。
3.如果在cpp⽂件中声明宏、结构体、函数等，那么我要在另⼀个cpp⽂件中引⽤相应的宏、结构体、函数，就必须再做⼀次重复的⼯作（意思是说如果不去#include），如果我改了⼀个cpp⽂件中的⼀个声明，那么⼜忘了改其它cpp⽂件中的声明，这不就出了⼤问题了，程序的逻辑就变成了你不可想象的了，如果把这些公共的东东放在⼀个头⽂件中，想⽤它的cpp⽂件就只需要引⽤⼀个就OK了这样岂不⽅便，要改某个声明的时候，只需要动⼀下头⽂件就⾏了。
CC++头文件的作用和用法
CC++头文件的作用和用法头文件是C/C++程序不可缺少的组成部分。
使用头文件，应该注意头文件的作用和用法相关知识点。
1.头文件的作用C/C++编译器采用的是分离编译模式。
在一个项目中，有多个源文件存在，但是它们总会有一些内容是相同的，如使用相同的用户自定义类型、使用了相同的全局变量等。
因此，将这些内容抽取出来放到头文件中，然后在提供给各个源文件包含，就可以避免这些内容的重复书写，提高编程效率和代码安全性。
所以，设立头文件的目的主要是：提供全局变量、全局函数的声明或提供公用数据类型的定义，从而实现分离变异或代码复用。
在这里，有一个判断头文件中的内容是否合适的简单准则：规范的头文件应该被多个源文件包含而不引发编译错误。
概括的说，头文件有如下三个作用。
（1）加强类型检查，提高代码得类型安全性。
在C++中使用头文件，对自定义类型的安全也是非常重要的。
虽然，在语法上，同一个数据类型（如一个class）在不同的源文件中书写多次是允许的，程序员认为他们是同一个自定义类型。
但是，由于用户自定义类型不具有外部连接特性，编译器并不关心该类型的多个版本之间是否一致，这样会导致逻辑错误的发生。
考察如下程序。
//source1.cpp#include<iostream>class A{private:char num;public:A();void show();};void A::show(){std::cout<<num<<std::endl;}void see(A&a){a.show();}//end source1.cpp//source2.cpp#include<iostream>class A{private:int num;public:A(){num=5;};void show();};void see(A& a);int main(){A a;see(a);getchar();}//end source2.cpp这个程序能够顺利通过编译并正确的运行，在在构成项目的两个源文件中，对class A的定义出现了一点小小的不一致。
c语言头文件的工作原理
c语言头文件的工作原理C语言是一种广泛使用的编程语言，它的设计初衷是为了用于Unix操作系统。
C语言具有高效、灵活、可移植等特点，在操作系统、嵌入式系统、游戏开发等领域得到了广泛的应用。
在C语言中，头文件是一个非常重要的概念，本文将介绍C语言头文件的工作原理。
一、什么是头文件头文件是C语言中的一个概念，它通常包含一些函数、变量、结构体等的声明和定义。
在C语言中，头文件的扩展名通常是.h，例如stdio.h、stdlib.h等。
头文件通常包含在源代码中，它们可以被其他源文件包含，以便在编译时使用其中的函数、变量、结构体等。
二、头文件的作用头文件的作用非常重要，它可以提供一些声明和定义，以便在编译时使用。
例如，在C语言中，如果要使用printf函数，就需要包含stdio.h头文件，因为printf函数的声明和定义都在这个头文件中。
头文件还可以用于定义一些宏、常量、结构体等。
例如，stdbool.h 头文件中就定义了bool类型，它可以用于表示真假值。
头文件还可以用于扩展C语言的功能，例如，math.h头文件中就包含了许多数学函数，如sin、cos、tan等。
这些函数可以用于计算三角函数、对数函数等。
三、头文件的分类头文件可以分为系统头文件和用户头文件两种。
系统头文件是由操作系统提供的，用于提供系统级别的功能，例如，stdio.h、stdlib.h、math.h等。
用户头文件是由用户自己创建的，用于提供特定的功能，例如，mylib.h、myutil.h等。
系统头文件通常包含在编译器的安装目录中，例如，Windows平台下的Visual Studio编译器，其头文件通常位于C:Program Files (x86)Microsoft VisualStudio2017CommunityVCToolsMSVC14.16.27023include目录下。
用户头文件通常包含在项目的源代码中，它们可以被其他源文件包含，以便在编译时使用其中的函数、变量、结构体等。
C语言头文件的作用
C语言头文件的作用C语言头文件的作用最近在工作当中遇到了一点小问题,关于C语言头文件的应用问题,主要还是关于全局变量的定义和声明问题.学习C语言已经有好几年了,工作使用也近半年了,但是对于这部分的东西的确还没有深入的思考过.概念上还是比较模糊的,只是之前的使用大多比较简单,并没有牵涉到太复杂的工程,所以定义和声明还是比较简单而明了了的.但是最近的大工程让我在这方面吃到了一点点苦头,虽然看了别人的代码能够很快的改正,但是这些改正背后的原因却不知道.我想大多数喜欢C语言的程序员应该是和我一样的,总喜欢去追究程序问题背后的底层原因,而这也恰恰是我喜欢C语言的最根本的原因.今天看过janders老兄在csdn上的一篇文章后,理解的确加深了很多,而且还学到一些以前不怎么知道的知识.现将文章转载过来,并对文章当中的一些拼写错误做了简单的纠正,同时对文字及布局做了少许修改. (如果想看原文的,请参考本文底部的链接.)--------------------------------------------------------------------------------C语言中的.h文件和我认识由来已久，其使用方法虽不十分复杂，但我却是经过了几个月的“不懂”时期，几年的“一知半解”时期才逐渐认识清楚他的本来面目。
揪其原因，我的驽钝和好学而不求甚解固然是原因之一，但另外还有其他原因。
原因一：对于较小的项目，其作用不易被充分开发，换句话说就是即使不知道他的详细使用方法，项目照样进行，程序在计算机上照样跑。
原因二：现在的各种C语言书籍都是只对C语言的语法进行详细的不能再详细的说明，但对于整个程序的文件组织构架却只字不提，找了好几本比较著名的C语言著作，却没有一个把.h文件的用法写的比较透彻的。
下面我就斗胆提笔，来按照我对.h的认识思路，向大家介绍一下。
让我们的思绪乘着时间机器回到大学一年级。
C原来老师正在讲台上讲着我们的第一个C语言程序: Hello world!文件名 First.cmain(){printf(“Hello world!”);}例程-1看看上面的程序，没有.h文件。
C语言头文件作用及写法
C语言头文件作用及写法头文件几个好处：1，头文件可以定义所用的函数列表，方便查阅你可以调用的函数；2，头文件可以定义很多宏定义，就是一些全局静态变量的定义，在这样的情况下，只要修改头文件的内容，程序就可以做相应的修改，不用亲自跑到繁琐的代码内去搜索。
3，头文件只是声明，不占内存空间，要知道其执行过程，要看你头文件所申明的函数是在哪个.c文件里定义的，才知道。
4，他并不是C自带的，可以不用。
5，调用了头文件，就等于赋予了调用某些函数的权限，如果你要算一个数的N次方，就要调用Pow（）函数，而这个函数是定义在math.c里面的，要用这个函数，就必需调用math.h 这个头文件。
头文件写法：#include <vcl.h>...//-------------------------------#ifndef MY_POINT#define MY_POINTclass Class1{}class Class2{}...#endif在要使用类定义的文件中加入#include "头文件名.h "一般来说，头文件里多数是放的函数定义或函数体。
此外，还有：#ifndef ****#define ****……#endif之类的语句，用于控制#define 与#endif之间的内容不被重复定义或插入。
#include 语句起的只是一个插入作用。
也就是说，#include 的文件里的内容可以随便写。
编译器使用#include 的文件里的内容来插入到#include 所在位置。
所以，你说的“头文件”没有固定格式。
如要使用其它头文件中的函数，可以直接在你的头文件中引用。
初学C语言，个人建议你使用C++Builder 6去练习和理解，当然，这要求你有一定的英语水平.在很多情况下会自动的帮你加好头文件，你可以观察它自动生成的文件，代码，以进一步学习。
example：我截了一小段/* math.hDefinitions for the math floating point package.Copyright (c) 1987, 1991 by Borland InternationalAll Rights Reserved.*/#ifndef __MATH_H#define __MATH_H#if !defined( __DEFS_H )#include <_defs.h>#endif#define HUGE_VAL _huge_dbleextern double _Cdecl _huge_dble;#define _LHUGE_VAL _huge_ldbleextern long double _Cdecl _huge_ldble;#ifdef __cplusplusextern "C" {#endifdouble _Cdecl acos (double __x);double _Cdecl asin (double __x);double _Cdecl atan (double __x);double _Cdecl atan2 (double __y, double __x);double _Cdecl ceil (double __x);double _Cdecl cos (double __x);double _Cdecl cosh (double __x);double _Cdecl exp (double __x);double _Cdecl fabs (double __x);double _Cdecl __fabs__ (double __x); /* Intrinsic */double _Cdecl floor (double __x);double _Cdecl fmod (double __x, double __y);double _Cdecl frexp (double __x, int *__exponent);double _Cdecl ldexp (double __x, int __exponent);double _Cdecl log (double __x);double _Cdecl log10 (double __x);double _Cdecl modf (double __x, double *__ipart);double _Cdecl pow (double __x, double __y);double _Cdecl sin (double __x);double _Cdecl sinh (double __x);double _Cdecl sqrt (double __x);double _Cdecl tan (double __x);double _Cdecl tanh (double __x);long double _Cdecl acosl (long double __x);long double _Cdecl asinl (long double __x);long double _Cdecl atan2l (long double __x, long double __y);long double _Cdecl atanl (long double __x);long double _Cdecl ceill (long double __x);long double _Cdecl coshl (long double __x);long double _Cdecl cosl (long double __x);long double _Cdecl expl (long double __x);long double _Cdecl fabsl (long double __x);long double _Cdecl floorl (long double __x);long double _Cdecl fmodl (long double __x, long double __y); long double _Cdecl frexpl (long double __x, int *__exponent);long double _Cdecl ldexpl (long double __x, int __exponent);long double _Cdecl log10l (long double __x);long double _Cdecl logl (long double __x);long double _Cdecl modfl (long double __x, long double *__ipart); long double _Cdecl powl (long double __x, long double __y); long double _Cdecl sinhl (long double __x);long double _Cdecl sinl (long double __x);long double _Cdecl sqrtl (long double __x);long double _Cdecl tanhl (long double __x);long double _Cdecl tanl (long double __x);typedef enum{DOMAIN = 1, /* argument domain error -- log (-1) */ SING, /* argument singularity -- pow (0,-2)) */OVERFLOW, /* overflow range error -- exp (1000) */ UNDERFLOW, /* underflow range error -- exp (-1000) */ TLOSS, /* total loss of significance -- sin(10e70) */PLOSS, /* partial loss of signif. -- not used */STACKFAULT /* floating point unit stack overflow */} _mexcep;#ifdef __cplusplus}#endif1）所有C++的源文件均必须包含一个规范的文件头，文件头包含了该文件的名称、功能概述、作者、版权和版本历史信息等内容。
c语言中头文件和源文件解析 编译原理
c语言中头文件和源文件解析编译原理头文件和源文件是C语言中常见的两种文件类型，它们在编译原理中扮演着重要的角色。
本文将对头文件和源文件进行解析，从编译原理的角度探讨它们的作用和使用方法。
一、头文件的概念和作用头文件是一种特殊的文件，它通常以.h作为文件扩展名，用于存放函数声明、宏定义、结构体声明等内容。
头文件的作用主要有以下几个方面：1.1 提供接口声明头文件中包含了函数的声明，通过包含头文件可以让源文件知道这些函数的存在，并且能够正确地调用这些函数。
这种方式可以提高代码的可读性和可维护性，使得不同的源文件可以共享同一个函数的实现。
1.2 定义常量和宏头文件中可以定义常量和宏，这些常量和宏可以被多个源文件引用和使用。
通过在头文件中定义常量和宏，可以提高代码的可重用性和可维护性，避免了在多个源文件中重复定义常量和宏的问题。
1.3 声明结构体和类型头文件中可以声明结构体和类型，这些结构体和类型可以被多个源文件引用和使用。
通过在头文件中声明结构体和类型，可以提高代码的可读性和可维护性，避免了在多个源文件中重复声明结构体和类型的问题。
二、源文件的概念和作用源文件是C语言程序的主要组成部分，它通常以.c作为文件扩展名，包含了具体的函数实现和全局变量定义等内容。
源文件的作用主要有以下几个方面：2.1 实现函数的定义源文件中包含了函数的具体实现，通过编译和链接的过程，可以将函数的定义和函数的调用联系起来。
源文件中的函数实现可以直接访问和修改全局变量，同时也可以调用其他源文件中的函数。
2.2 定义全局变量源文件中可以定义全局变量，这些全局变量可以被多个函数访问和修改。
全局变量在程序的整个执行过程中都是存在的，它们的作用域不限于某个函数，可以在不同的函数之间共享数据。
2.3 包含头文件源文件可以通过包含头文件来使用头文件中定义的函数、常量、宏、结构体和类型等。
通过包含头文件，源文件可以获取到头文件中的声明信息，从而可以正确地使用其中定义的内容。
c语言中头文件的作用和使用方法
c语言中头文件的作用和使用方法C语言中头文件的作用和使用1. 什么是头文件？在C语言中，头文件是包含一些预定义的常量、宏定义、函数声明或数据结构定义的文件。
头文件的扩展名通常为.h，它可以被包含在C语言源代码中，以便在编译时进行预处理。
2. 头文件的作用头文件的主要作用有以下几点：•提供函数和变量的声明：头文件中可以包含函数的声明，使得其他源代码文件可以调用声明在头文件中的函数，而不需要重复写函数的原型声明。
•定义常量和宏：头文件中可以包含常量和宏的定义，以便在不同的源代码文件中共享使用。
•实现模块化编程：通过将相关函数和变量的声明和定义放在同一个头文件中，可以实现代码的模块化，提高代码的可读性和可维护性。
•提高编译速度：由于头文件中的内容可以在编译前进行预处理，预处理器会将头文件的内容直接复制到源代码文件中，避免了重复代码的输入，也可以加快编译速度。
3. 头文件的使用3.1 包含头文件在C语言源代码中，通过使用#include指令可以包含头文件。
一般情况下，包含头文件的方式有两种：•使用尖括号<>包含系统提供的头文件：例如#include <stdio.h>，这种方式会在系统目录中查找相应的头文件。
•使用双引号""包含自定义的头文件：例如#include"myheader.h"，这种方式会首先在当前目录中查找相应的头文件，如果找不到再去系统目录中查找。
3.2 防止重复包含由于头文件的常见作用是提供声明和定义，为了防止多次包含同一个头文件引起的重定义错误，可以在头文件中使用预处理指令#ifndef、#define、#endif进行包含防护。
#ifndef MYHEADER_H#define MYHEADER_H// 头文件内容#endif这样，在多个源代码文件中包含同一个头文件时，只会包含一次，避免了重复定义的错误。
4. 常见的C标准库头文件C语言提供了一些常见的标准库头文件，包含了一些常用的函数和宏定义。
c语言头文件定义和运用
c语言头文件定义和运用C语言头文件定义和运用在C语言中，头文件是一种重要的编程元素，用于定义函数原型、宏定义和数据结构。
头文件可以帮助程序员更好地组织和管理代码，提高代码的可读性和可维护性，并方便代码的复用。
本文将一步一步回答有关C语言头文件定义和运用的问题。
问题1：什么是C语言头文件？答：C语言头文件是一种扩展名为.h的文件，用于存储函数原型、宏定义和数据结构的声明。
C语言源文件通常会通过in c l u d e指令引用头文件，以便在源文件中使用头文件中定义的函数和常量。
问题2：为什么在C语言中需要头文件？答：头文件的引入可以将一些常用功能和数据结构的声明集中起来，方便程序员的使用和维护。
通过引入头文件，可以在源文件中使用其他文件中定义的函数和常量，而无需再次编写它们的声明。
问题3：如何创建一个头文件？答：要创建一个头文件，首先需要使用文本编辑器创建一个新文件，命名为.h，并在文件中编写函数原型、宏定义和数据结构的声明等内容。
然后，将该文件保存在源文件所在目录中，即可在源文件中使用i n c l u d e指令引用头文件。
问题4：头文件的命名规则有什么要求？答：C语言中的头文件命名约定一般采用全大写的方式，单词之间使用下划线分隔，以便提高代码的可读性和可维护性。
例如，常用的标准库头文件就采用了以下命名规则：s t d i o.h，s t d l i b.h等。
问题5：头文件中应该包含哪些内容？答：头文件中应包含函数原型、宏定义、结构体、共用体和枚举等的声明。
通常情况下，如果一个函数会被多个源文件使用，或者函数体较长，建议将函数原型写在头文件中，并在源文件中i n c l u d e该头文件。
问题6：如何使用头文件中的函数和常量？答：要使用头文件中定义的函数和常量，我们需要在源文件中使用i n c l u d e指令引入头文件。
引入头文件后，就可以直接在源文件的函数中调用头文件中定义的函数，并使用其中声明的常量。
C语言多文件编程的注意事项
C语言多文件编程的注意事项在C语言编程中，多文件编程是一种常见的开发方式。
通过将代码分散到多个文件中，可以提高代码的可读性和维护性。
然而，多文件编程也存在一些需要注意的事项。
本文将探讨C语言多文件编程的一些注意事项。
一、文件组织结构在进行多文件编程时，良好的文件组织结构是非常重要的。
通常，我们可以将相关的函数和数据结构放在同一个文件中。
例如，如果我们正在开发一个学生信息管理系统，可以将与学生相关的函数和数据结构放在一个文件中，将与课程相关的函数和数据结构放在另一个文件中。
这样做有助于提高代码的可读性和维护性。
另外，需要注意的是，每个文件应该有一个明确的目的。
避免将过多的功能放在同一个文件中，这样会导致代码的复杂性增加，不利于后续的维护和扩展。
二、头文件的使用头文件在多文件编程中起着重要的作用。
它们包含了函数声明、宏定义和类型定义等信息，可以让不同的文件之间进行函数调用和数据共享。
在使用头文件时，有几个注意事项需要牢记。
首先，避免在头文件中放置过多的代码。
头文件应该尽量保持简洁，只包含必要的声明和定义。
这样可以减少编译时间，并降低出错的可能性。
其次，使用预处理指令来避免重复包含头文件。
在每个头文件的开头，使用条件编译指令来判断该头文件是否已经被包含。
例如：#ifndef HEADER_FILE_H#define HEADER_FILE_H// 头文件内容#endif这样可以避免同一个头文件被重复包含，造成编译错误。
三、全局变量的使用在多文件编程中，全局变量的使用需要格外小心。
全局变量可以在不同的文件中进行访问和修改，但也容易导致代码的混乱和不可预测的错误。
为了避免全局变量的滥用，应该尽量将变量的作用域限制在函数内部或者使用局部变量。
如果确实需要在多个文件中共享数据，可以使用extern关键字来声明全局变量。
例如，在一个文件中定义全局变量：int global_var;然后在其他文件中使用该变量时，使用extern关键字进行声明：extern int global_var;这样可以确保多个文件共享同一个全局变量。
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语言所有常用头文件用途
C语言所有常用头文件用途C语言是一种通用的、面向过程的编程语言，它提供了丰富的标准库和头文件，以便开发人员可以更轻松地进行软件开发。
本文将介绍常用的C语言头文件及其用途，帮助读者更好地理解和使用这些头文件。
1. `<stdio.h>`：该头文件包含了C语言标准输入输出的函数和宏定义。
例如，`printf(`可以输出字符串和其他数据类型到控制台。
2. `<stdlib.h>`：该头文件包含了C语言的基本函数库，例如`malloc(`和`free(`用于动态内存分配，`atoi(`用于字符串和整数之间的转换。
3. `<string.h>`：该头文件包含了关于字符串操作的函数和宏定义，例如`strcpy(`和`strcmp(`用于复制和比较字符串。
4. `<ctype.h>`：该头文件包含了字符处理函数和宏定义。
例如，`isalpha(`用于判断一个字符是否为字母，`toupper(`和`tolower(`用于将字符转换为大写或小写。
5. `<math.h>`：该头文件包含了数学函数和宏定义，例如`sin(`和`cos(`用于计算三角函数值，`pow(`用于计算指数函数值。
7. `<stdbool.h>`：该头文件定义了`bool`类型和`true`、`false`常量，用于布尔值的表示。
8. `<limits.h>`：该头文件定义了整数类型的取值范围和其他常量，例如`INT_MAX`表示整型的最大值。
9. `<stddef.h>`：该头文件定义了一些常用的类型和宏定义，例如`NULL`表示空指针，`size_t`表示无符号整数类型。
10. `<assert.h>`：该头文件定义了`assert(`宏，用于进行断言检查，当条件不满足时终止程序运行。
11. `<errno.h>`：该头文件定义了全局变量`errno`，用于表示函数调用出错时的错误代码。
c语言中头文件的作用和使用方法(一)
c语言中头文件的作用和使用方法(一)C语言中头文件的作用和使用什么是头文件?头文件是C语言中一种用于包含其他文件内容的文件。
它通常具有.h文件扩展名，并包含一组声明、宏定义和类型定义等。
头文件中的内容可以在多个源文件中重复使用，从而提高了代码的可复用性和维护性。
头文件的作用头文件在C语言中具有以下几个重要的作用：1.声明函数和变量: 头文件中常常包含函数和变量的声明，以便在源文件中使用。
这样做可以将函数和变量的声明与定义分离，使代码更加清晰和易读。
2.定义宏: 头文件可以包含宏定义，例如常用的预处理宏、条件编译宏等。
这些宏的定义可以在整个程序中全局有效，方便代码的使用和维护。
3.类型定义: 头文件中可以定义自定义的数据类型，例如结构体、枚举等。
这样可以将相关的数据类型集中在一个地方，提高代码的组织结构和可读性。
4.库函数引入: 头文件可以引入外部库函数的声明，使得我们可以直接调用这些函数而无需手动声明。
这样可以简化代码，并提高开发效率。
头文件的使用方法头文件的使用方法主要有两种：包含系统头文件和包含自定义头文件。
包含系统头文件系统头文件是C语言提供的一些标准头文件，用于声明常用的函数、类型和宏定义等。
我们可以通过#include指令来包含系统头文件，例如：#include <stdio.h>#include <stdlib.h>#include <string.h>使用这些系统头文件可以直接使用其中定义的函数、类型等，无需手动声明。
包含自定义头文件自定义头文件是我们根据需要创建的头文件，用于包含自己定义的函数、变量和类型等。
我们可以通过#include指令来包含自定义头文件，例如：#include "myheader.h"在自定义头文件myheader.h中，我们可以声明自己的函数、变量和类型等，供其他源文件使用。
头文件的注意事项在使用头文件时，需要注意以下几点：1.避免重复包含: 头文件中的内容可以在多个源文件中重复使用，但为了防止重复定义，需要在头文件中使用条件编译指令，例如：#ifndef MYHEADER_H#define MYHEADER_H// 头文件内容#endif这样可以避免重复包含，提高代码的编译效率。
C｜头文件使用源由及可以包含什么、不能包含什么
C｜头文件使用源由及可以包含什么、不能包含什么展开全文通常，在一个C++ 程序中，我们需要写多个.cpp文件，如果多个.cpp文件都要用到某个函数，如print()，不可能在每一个.cpp文件中都定义一份，C++的做法是多处声明、一处定义，编译时只需有声明（告诉编译器，这个声明在别处有定义），链接时在整个项目中再寻找定义。
这些声明可以写到一个.h头文件中，被多个.cpp文件包含，在编译前通过预处理器做一次查找、替换。
各.cpp文件最终是要链接在一起的：一、C++ 编译模式C++ 语言支持'分别编译'（separate compilation）。
也就是说，一个程序所有的内容，可以分成不同的部分分别放在不同的 .cpp 文件里。
.cpp 文件里的东西都是相对独立的，在编译（compile）时不需要与其他文件互通，只需要在编译成目标文件后再与其他的目标文件做一次链接（link）就行了。
比如，在文件 a.cpp 中定义了一个全局函数 'void a(){}'，而在文件 b.cpp 中需要调用这个函数，只需先声明，告诉编译器，这个声明在别处有定义，在下一链接阶段去找到这个定义就行了。
所以说，文件 a.cpp 和文件 b.cpp 并不需要相互知道对方的存在，可以分别地对它们进行编译，编译成目标文件之后再链接，整个程序就可以运行了。
这是怎么实现的呢？从写程序的角度来讲，很简单。
在文件b.cpp 中，在调用'void a()' 函数之前，先声明一下这个函数'void a();'，就可以了。
这是因为编译器在编译b.cpp 的时候会生成一个符号表（symbol table），像 'void a()' 这样的看不到定义的符号，就会被存放在这个表中。
再进行链接的时候，编译器就会在别的目标文件（实现文件）中去寻找这个符号的定义。
一旦找到了，程序也就可以顺利地生成了，如果找不到，则会产生链接错误。
c语言中关于头文件的注意事项
c语⾔中关于头⽂件的注意事项
1.头⽂件是什么，其加载⽅式？
程序中.h⽂件即是头⽂件，主要是⽅便引⽤其他的⽂件内容。
引⽤头⽂件⽅式有两种：引⽤系统头⽂件<>，引⽤⽤户头⽂件""。
当在某⼀⽂件中引⽤另⼀头⽂件时，相当于将该头⽂件中的内容全部复制进来。
2.头⽂件中⼀般包含哪些内容？其可以定义变量吗？
头⽂件中⼀般包含⼀些宏定义、全局变量和函数声明。
声明不会产⽣内存的分配。
当我们在.h⽂件中声明⼀个变量时，由于仅是简单的声明，其不产⽣内存分配。
其他⽂件在引⽤该头⽂件时，相当于各⾃定义了⼀个局部变量，但是各个⽂件中的变量是独⽴存在的，其各⾃有⾃⼰的内存位置。
数据各不相同，这样的变量有什么意义呢。
因此我们⼀般在.h⽂件中声明常量。
如果我们需要定义全局变量，可以在.c⽂件中定义，然后在.h⽂件中进⾏声明。
这样其他⽂件引⽤时，可以直接使⽤该全局变量。
C++笔记：头文件的作用和写法
C++笔记：头⽂件的作⽤和写法from://在 C++ 中有⼀个很重要的概念就是头⽂件。
之所以在 C++ 中要使⽤头⽂件，最主要的原因是 C++ 的同⼀个项⽬可能有多个源代码⽂件，要命的是这些源代码是分别单独编译的。
也就是说，在编译其中⼀个⽂件时，编译器并不知道其它⽂件中定义的内容，如类、全局变量等。
这就要求我们必须在要使⽤某个类、函数或变量的每个⽂件中声明它，否则 C++ 是⽆法找到它的。
例如：假设你写了⼀个通⽤的函数 add，它的定义如下：CPP1 2 3 4int add(int a, int b) {return a+b;}很多⽂件可能都需要使⽤加法。
假设有⼀个⽂件 b.cpp 需要使⽤这个函数，那么，它必须先声明它，虽然不需要再重写。
CPP1 2int add(int a, int b); add(5,5);如果有很多⽂件都要使⽤这个函数，那么这会变得⿇烦，特别的，如果你写了⼀个类，那么你需要维护⼤量的声明（对于每⼀个 public 对象），并且如果你的类的定义发⽣了改变，你可能不得不改变⽆数个声明。
所以，C++ 语⾔提出了头⽂件的概念。
你只需要在头⽂件中声明⼀次，在实现⽂件中定义⼀次，在所有需要⽤的⽂件中，就只需要引⽤这个头⽂件，相当于每个⽂件都包含了⼀个声明。
为了防⽌头⽂件的重复包含，通常应该使⽤预处理指令 #define （定义符号）、#ifndef（如果没有定义）、#endif（结束判断）来书写头⽂件的内容。
请理解如下的例⼦，它是对上个笔记中的 Xiao 类的改进。
Xiao 类的实现（xiao.cpp）CPP1 2 3 4 5 6 7 8 9 10 11#include "xiao.h"bool Xiao::MobaiXiao(){return this->mobai("xiao", 10000); // 正确}bool Xiao::mobai(char* cowname, int mobai_times) {// 膜拜神⽜。
C语言入门：为什么不要在头文件中定义变量和函数
C语言入门：为什么不要在头文件中定义变量和函数把变量统统定义到另外一个头文件里，不要重复引用，再把相对应的声明和方法都写在一个头文件里，函数和类都通过指针、引用和形参调用变量或值。
这样就啥毛病都不会有。
作为退休C程序员，昨天在头条看到一篇类似文章，洋洋洒洒几千字，完全不得要领，弄得一堆新手C程序员在评论中疑惑，在下忍不住手痒，放下钓鱼竿来写这篇文章。
C语言新手仔细阅读后，会有一定的领悟和提升。
首先开宗明义：头文件的作用只是声明变量和函数，C文件才是做定义的地方。
我们一步步来解释, 为了节省篇幅，我们尽量简化程序逻辑,不做错误判断。
新手C程序员李雷上了两节课以后，他会写的都是把整个程序都写在一个C文件里面：main.c:这个程序的作用很简单，就是不停地从终端输入数字，然后累加，打印出结果。
教授很满意，给了李雷一个赞。
然后教授开始引导李雷学习C语言工程的概念，也就是说将来的程序越来越大，你横不能把所有的东西都写在 main.c 里面吧，聪明的李雷想了想，非常有道理，于是教授告诉他，要把一些可以复用的代码从 main.c 里面分离出来，这样既不至于让编译器对着一个超大c文件发疯，也方便程序员维护。
聪明的李雷立刻领会了教授的意思，他把 adjust_money() 函数分离出来了，于是写下了三个文件：func.hfunc.cmain.c教授看了看，疑惑地问李雷：你为啥要把 int money 放在头文件里面呢？李雷说：“我考虑到万一需要直接访问这个变量，所以把它定义为全局变量了。
”教授点点头，说：“这个考虑是没问题的，但你想过没有，你在func.h 里面定义了这个 money ，会导致你的程序无法连接。
”李雷摇头说：“没问题啊，不信你看。
”李雷得意地看着教授说：“你看，编译没问题啊。
”教授摇头说：“我说的是你没办法连接，不是说你没办法编译。
不信你试试看把它连接成一个可执行文件。
”李雷将信将疑地试着连接:果然，编译器报错了，money 这个变量被重复定义了，李雷没办法按预期的获得可执行文件。
C语言中的头文件与原文件
C语言中的头文件与原文件简单的说其实要理解C文件与头文件（即.h）有什么不同之处，首先需要弄明白编译器的工作过程，一般说来编译器会做以下几个过程：1.预处理阶段2.词法与语法分析阶段3.编译阶段，首先编译成纯汇编语句，再将之汇编成跟CPU相关的二进制码，生成各个目标文件(.obj文件)4.连接阶段，将各个目标文件中的各段代码进行绝对地址定位，生成跟特定平台相关的可执行文件，当然，最后还可以用objcopy生成纯二进制码，也就是去掉了文件格式信息。
（生成.exe 文件）编译器在编译时是以C文件为单位进行的，也就是说如果你的项目中一个C文件都没有，那么你的项目将无法编译，连接器是以目标文件为单位，它将一个或多个目标文件进行函数与变量的重定位，生成最终的可执行文件，在PC上的程序开发，一般都有一个main函数，这是各个编译器的约定，当然，你如果自己写连接器脚本的话，可以不用main函数作为程序入口（main.c文件目标文件可执行文件）有了这些基础知识，再言归正传，为了生成一个最终的可执行文件，就需要一些目标文件，也就是需要C文件，而这些C文件中又需要一个main函数作为可执行程序的入口，那么我们就从一个C文件入手，假定这个C文件内容如下：#include#include"mytest.h"intmain(intargc,charargv){test=25;printf("test.................%d/n", test);}头文件内容如下：inttest;现在以这个例子来讲解编译器的工作：1.预处理阶段：编译器以C 文件作为一个单元，首先读这个C文件，发现第一句与第二句是包含一个头文件，就会在所有搜索路径中寻找这两个文件，找到之后，就会将相应头文件中再去处理宏，变量，函数声明，嵌套的头文件包含等，检测依赖关系，进行宏替换，看是否有重复定义与声明的情况发生，最后将那些文件中所有的东东全部扫描进这个当前的C文件中，形成一个中间“C文件”2.编译阶段，在上一步中相当于将那个头文件中的test变量扫描进了一个中间C文件，那么test变量就变成了这个文件中的一个全局变量，此时就将所有这个中间C文件的所有变量，函数分配空间，将各个函数编译成二进制码，按照特定目标文件格式生成目标文件，在这种格式的目标文件中进行各个全局变量，函数的符号描述，将这些二进制码按照一定的标准组织成一个目标文件3.连接阶段，将上一步成生的各个目标文件，根据一些参数，连接生成最终的可执行文件，主要的工作就是重定位各个目标文件的函数，变量等，相当于将个目标文件中的二进制码按一定的规范合到一个文件中再回到C文件与头文件各写什么内容的话题上：理论上来说C文件与头文件里的内容，只要是C语言所支持的，无论写什么都可以的，比如你在头文件中写函数体，只要在任何一个C文件包含此头文件就可以将这个函数编译成目标文件的一部分（编译是以C文件为单位的，如果不在任何C文件中包含此头文件的话，这段代码就形同虚设），你可以在C文件中进行函数声明，变量声明，结构体声明，这也不成问题那为何一定要分成头文件与C文件呢？又为何一般都在头件中进行函数，变量声明，宏声明，结构体声明呢？而在C 文件中去进行变量定义，函数实现呢？？原因如下：1.如果在头文件中实现一个函数体，那么如果在多个C文件中引用它，而且又同时编译多个C文件，将其生成的目标文件连接成一个可执行文件，在每个引用此头文件的C文件所生成的目标文件中，都有一份这个函数的代码，如果这段函数又没有定义成局部函数，那么在连接时，就会发现多个相同的函数，就会报错2.如果在头文件中定义全局变量，并且将此全局变量赋初值，那么在多个引用此头文件的C文件中同样存在相同变量名的拷贝，关键是此变量被赋了初值，所以编译器就会将此变量放入DATA段，最终在连接阶段，会在DATA段中存在多个相同的变量，它无法将这些变量统一成一个变量，也就是仅为此变量分配一个空间，而不是多份空间，假定这个变量在头文件没有赋初值，编译器就会将之放入BSS段，连接器会对BSS段的多个同名变量仅分配一个存储空间3.如果在C文件中声明宏，结构体，函数等，那么我要在另一个C文件中引用相应的宏，结构体，就必须再做一次重复的工作，如果我改了一个C文件中的一个声明，那么又忘了改其它C文件中的声明，这不就出了大问题了，程序的逻辑就变成了你不可想象的了，如果把这些公共的东东放在一个头文件中，想用它的C文件就只需要引用一个就OK了这样岂不方便，要改某个声明的时候，只需要动一下头文件就行了4.在头文件中声明结构体，函数等，当你需要将你的代码封装成一个库，让别人来用你的代码，你又不想公布源码，那么人家如何利用你的库呢？也就是如何利用你的库中的各个函数呢？？一种方法是公布源码，别人想怎么用就怎么用，另一种是提供头文件，别人从头文件中看你的函数原型，这样人家才知道如何调用你写的函数，就如同你调用printf函数一样，里面的参数是怎样的？？你是怎么知道的？？还不是看人家的头文件中的相关声明啊当然这些东东都成了C标准，就算不看人家的头文件，你一样可以知道怎么使用c语言中.c和.h文件的困惑?本质上没有任何区别。
单片机中用c编程时头文件解析
sfr SBUF= 0x99; sfr P2 = 0xA0; sfr IE= 0xA8; sfr P3 = 0xB0; sfr IP = 0xB8; sfr T2CON= 0xC8; sfr T2MOD= 0xC9; sfr RCAP2L= 0xCA; sfr RCAP2H= 0xCB; sfr TL2= 0xCC; sfr TH2= 0xCD; sfr PSW= 0xD0; sfr ACC= 0xEIE */ sbit EA = 0xAF; sbit ES = 0xAC; sbit ET1 = 0xAB; sbit EX1 = 0xAA; sbit ET0 = 0xA9; sbit EX0 = 0xA8; /* IP */ sbit PS = 0xBC; sbit PT1 = 0xBB; sbit PX1 = 0xBA; sbit PT0 = 0xB9; sbit PX0 = 0xB8; /* P3 */ sbit RD = 0xB7; sbit WR = 0xB6;
单片机中用c 单片机中用c编程时头文件解析
单片机中用c编程时头文件 单片机中用 编程时头文件reg51.h及reg52.h解析 编程时头文件 及 解析 我们在用c语言编程是往往第一行就是 我们在用 语言编程是往往第一行就是reg52.h或者 语言编程是往往第一行就是 或者 其他的自定义头文件，我们怎么样来理解呢？ 其他的自定义头文件，我们怎么样来理解呢？ #include<at89x52.h> /*包含库函数 */ 包含库函数
2)特殊功能寄存器定义（sfr): sfrt 变量名 地址值 特殊功能寄存器定义（ 变量名=地址值 特殊功能寄存器定义
#ifndef __AT89X52_H__ #define __AT89X52_H__
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
积分:912
于 2005-03-31 16:50
谭好强的 C语言 条件编译（宏）那一部分再好好看看
simonjp@ 贾鹏
msn:Myheart356@
孔子东游，遇二小儿辩斗，问其故。一小儿曰：我以日本生自山东，故属东。
一小儿曰：夕阳西下，日本归山西也明矣，是以属西。 孔子不能决，后以问老子（就是我）。 老子笑曰：孰为汝多知乎？日本无根基，岂能算东西 ！！
快速回复
标题
内容
论坛技术分统计
已读帖子
新的帖子
被删除的帖子
返回研学论坛首页 返回网站首页
广告服务 | 隐私政策 | 联系我们 | 设为首页
Powered by Powerful JuteForum® Version Jute 1.5.1 Ent
发贴: 13
技术分: 0
积分:14
于 2005-03-24 15:12
”3、疑问
1）、C++如何保证一个头文件仅被一个源文件包含一次？
答：设头文件为func.h,则func.h如下：
#if !define(AFX_FUNC_H__X..X__INCLUDED_)
函数声明，如extern int fn(char s);
类联函数定义，如inline char fn(char *p){return *p;}
类型声明，如struct BTNode{char data; BTNode *left,*right;};
包含指令，如#include "xtu\index.h"
于 2005-03-28 10:14
多谢楼主了
作者Re:【分享】C，C++使用头文件的原因及注意事项 [Re:xtulbd1]
zhuqy
论坛游民
发贴: 5
技术分: 0
#define AFX_FUNC_H__X..X__INCLUDED_
......
#endif“
楼主，这个我还是不太明白，请详细地说一下好么？
作者Re:【分享】C，C++使用头文件的原因及注意事项 [Re:xtulbd1]
打印话题 寄给朋友 订阅主题
作者【分享】C，C++使用头文件的原因及注意事项
xtulbd1
论坛游民
发贴: 59
技术分: 1
积分:77
同一名字的具有外部存储类型的声明，可以在多个源文件中被引用，因此方便的方法是将它们
放在头文件中。头文件起着源文件之间接口的作用。
2、使用建议
头文件一般可包含：
常量定义，如const float pi=3.14;
变量声明，如extern int m; extern int a[];
于 2005-03-0ຫໍສະໝຸດ 18:47 C，C++使用头文件的原因及注意事项
--------------------------------------------------------------------------------
1、原理
研学论坛 - 【分享】C，C++使用头文件的原因及注意事项#158372
帮助 | 搜索 | 个人属性 | 注销 | 标记已读 | 我的论坛 | 排行榜 | 发帖统计
» 研学论坛 » C，C++，C# » C/C++ 基础
b10b
论坛游民
发贴: 1
技术分: 0
积分:1
于 2005-03-24 21:46
回楼上...
#if就是判断是否已包含同名.h
如果!define则可include "func.h"
显示个人签名
加密此帖，只对部分用户可见，用户技术分需大于
0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
积分:5
于 2005-03-31 13:33
现在还不是太懂！！
作者Re:【分享】C，C++使用头文件的原因及注意事项 [Re:xtulbd1]
myheart356
版主
发贴: 753
如果还看不懂,就............
作者Re:【分享】C，C++使用头文件的原因及注意事项 [Re:xtulbd1]
xianweizhu
论坛游民
发贴: 2
技术分: 0
积分:2
宏定义，如#define PI 3.1415926
类声明，如class Db{......};
头文件不宜包含：
变量定义，如int a; int b[5];
函数定义，如char fn(char *p){return *p;}
常量聚集定义，如const int c[]={1,2,3};
......
#endif
2）、头文件中声明类，为什么不在头文件中
a、初始化成员变量；
b、初始化成员常量；
c、初始化静态成员变量；
d、初始化构造函数；
e、初始化非内联成员函数？
答：由于上述操作对象均具全局性，若类定义头文件被一个源文件包含多次的话，
Copyright© 2002-2003 研学论坛 All Rights Reserved.
3、疑问
1）、C++如何保证一个头文件仅被一个源文件包含一次？
答：设头文件为func.h,则func.h如下：
#if !define(AFX_FUNC_H__X..X__INCLUDED_)
#define AFX_FUNC_H__X..X__INCLUDED_
将引起变量或常量或函数重定义的错误（一个编译单元<h+cpp>中包含重定义的变量或常量或函数）。
作者Re:【分享】C，C++使用头文件的原因及注意事项 [Re:xtulbd1]
qianxunboy
论坛游民
发贴: 2
技术分: 0
积分:2
于 2005-03-09 18:37
多谢
作者Re:【分享】C，C++使用头文件的原因及注意事项 [Re:xtulbd1]
dionysus_yan
论坛游民
HTML标记
笑脸标记
Jute标记
图片标记
选项Email通知：如果有回复就通知您
禁止在这个帖子中使用 Jute 标记
禁止在这个帖子中使用笑脸标记