c++头⽂件的使⽤和多个⽂件中如何共⽤⼀个全局变量
头⽂件只是⽤来声明的，不参与编译，#include “1.h”  只是把1.h⾥的代码给复制到这个源⽂件⾥来，建议还是好好看看上⾯这个
明确⼏个点：
1）不管变量还是函数先声明 或者直接定义才能使⽤，声明能声明n次，同⼀个作⽤域⾥⾯ 定义只能定义⼀次
2） 根据C++标准的规定，⼀个变量声明必须同时满⾜两个条件，否则就是定义：
(1)声明必须使⽤extern关键字；(2)不能给变量赋初值
extern  int  a;  //声明
int  a;  //定义
int  a  =  0; //定义
extern  int  a  =0;  //定义
3）⼀个全局变量的作⽤域默认是整个程序， 加了static 或者加了 const 则是这个源⽂件
4）如果在多个源⽂件 包含同⼀个名字的 全局变量的 定义，就会引起重定义
因此 要想在多个⽂件共⽤⼀个全局变量，我们只需在⼀个头⽂件⾥ 声明（注意是声明）这个变量 ： extern int i；
然后在 其中⼀个源⽂件 只能是⼀个（通常就是头⽂件的同名源⽂件）⾥⾯ 定义这个变量  int i =1；
注意不能⽤ i =1；  要⽤ int i =1；
最后在要使⽤这个变量的源⽂件⾥⾯  #include 头⽂件就⾏了
但是 const 或者 static 的全局变量 你在头⽂件⾥定义就没啥错，因为 它的作⽤域只是当前⽂件，也就是包含了这个头⽂件的这个源⽂件⾥⾯，就是内部链接，所以const的全局变量通常放在头⽂件内
所以如果在⼀个 头⽂件：
int i =1；
const int j = 2；
static int n =3；
然后在两个源⽂件都include了这个头⽂件，i是错的，重定义了，j和n没错
例⼦：
头⽂件：state.h  源⽂件：state.cpp
其它源⽂件：t1.cpp  t2.cpp  t3.cpp, 这些源⽂件都包含头⽂件state.h。
需要定义⼀个全局变量供这些源⽂件中使⽤：⽅法如下
1、在 state.h声明全局变量： extern int a;
2、在state.cpp中定义该全局变量：int a =10;
这样其它源⽂件就可以使⽤该变量啦
C++编译模式
通常，在⼀个C++程序中，只包含两类⽂件——.cpp⽂件和.h⽂件。其中，.cpp⽂件被称作C++源⽂件，⾥⾯放的都是C++的源代码；⽽.h ⽂件则被称作C++头⽂件，⾥⾯放的也是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++程序员们带来了很多好处，同时也引出了⼀种编写程序的⽅法。考虑⼀下，如果有⼀个很常⽤的函数“void f() {}”，在整个程序中的许多.cpp⽂件中都会被调⽤，那么，我们就只需要在⼀个⽂件中定义这个函数，⽽在其他的⽂件中声明这个函数就可以了。⼀个函数还好对付，声明起来也就⼀句话。但是，如果函数多了，⽐如是⼀⼤堆的数学函数，有好⼏百个，那怎么办？能保证每个程序员都可以完完全全地把所有函数的形式都 准确地记下来并写出来吗？c语言编译器怎么用?
什么是头⽂件
很显然，答案是不可能。但是有⼀个很简单地办法，可以帮助程序员们省去记住那么多函数原型的⿇烦：我们可以把那⼏百个函数的声明语句全都先写好，放在⼀个⽂件⾥，等到程序员需要它们的时候，就把这些东西全部copy进他的源代码中。
这个⽅法固然可⾏，但还是太⿇烦，⽽且还显得很笨拙。于是，头⽂件便可以发挥它的作⽤了。所谓的头⽂件，其实它的内容跟.cpp⽂件中的内容是⼀样的，都是C++的源代码。但头⽂件不⽤被编译。我们把所有的函数声明全部放进⼀个头⽂件中，当某⼀个.cpp源⽂件需要它们时，它们就可以通过⼀个宏命令 “#include”包含进这个.cpp⽂件中，从⽽把它们的内容合并到.cpp⽂件中去。当.cpp⽂件被编译时，这
些被包含进去的.h⽂件的作⽤便发挥了。
举⼀个例⼦吧，假设所有的数学函数只有两个：f1和f2，那么我们把它们的定义放在math.cpp⾥：
并把“这些”函数的声明放在⼀个头⽂件math.h中：
在另⼀个⽂件main.cpp中，我要调⽤这两个函数，那么就只需要把头⽂件包含进来：
这样，便是⼀个完整的程序了。需要注意的是，.h⽂件不⽤写在编译器的命令之后，但它必须要在编译器得到的地⽅（⽐如跟main.cpp 在⼀个⽬录下）。 main.cpp和math.cpp都可以分别通过编译，⽣成main.o和math.o，然后再把这两个⽬标⽂件进⾏链接，程序就可以运⾏了。
include
include 是⼀个来⾃C语⾔的宏命令，它在编译器进⾏编译之前，即在预编译的时候就会起作⽤。#include的作⽤是把它后⾯所写的那个⽂件的内容，完完整整地、 ⼀字不改地包含到当前的⽂件中来。值得⼀提的是，它本⾝是没有其它任何作⽤与副功能的，它的作⽤就是把每⼀个它出现的地⽅，替换成它后⾯所写的那个⽂件的 内容。简单的⽂本替换，别⽆其他。因此，main.cpp⽂件中的第⼀句（#include “math.h”），在编译之前就会被替换成math.h⽂件的内容。即在编译过程将要开始的时候，main.cpp的内容已经发⽣了改变：
不多不少，刚刚好。同理可知，如果我们除了main.cpp以外，还有其他的很多.cpp⽂件也⽤到了f1和f2函数的话，那么它们也通通只需要在使⽤这两个函数前写上⼀句#include “math.h”就⾏了。
头⽂件中应该写什么
通 过上⾯的讨论，我们可以了解到，头⽂件的作⽤就是被其他的.cpp包含进去的。它们本⾝并不参与编译，但实际上，它们的内容却在多个.cpp⽂件中得到了 编译。通过“定义只能有⼀次”的规则，我们很容易可以得出，头⽂件中应该只放变量和函数的声明，⽽不能放它们的定义。因为⼀个头⽂件的内容实际上是会被引⼊到多个不同的.cpp⽂件中的，并且它们都会被编译。放声明当然没事，如果放了定义，那么也就相当于在多个⽂件中出现了对于⼀个符号（变量或函数）的定 义，纵然这些定义都是相同的，但对于编译器来说，这样做不合法。
所以，应该记住的⼀点就是，.h头⽂件中，只能存在变量或者函数的声明， ⽽不要放定义。即，只能在头⽂件中写形如：extern int a；和void f()；的句⼦。这些才是声明。如果写上int a；或者void f() {}这样的句⼦，那么⼀旦这个头⽂件被两个或两个以上的.cpp⽂件包含的话，编译器会⽴马报错。（关于extern，前⾯有讨论过，这⾥不再讨论定义跟 声明的区别了。）
但是，这个规则是有三个例外的。
⼀，头⽂件中可以写const对象的定义。因为全局的const对象默 认是没有extern的声明的，所以它只在当前⽂件中有效。把这样的对象写进头⽂件中，即使它被包含到其他多个.cpp⽂件中，这个对象也都只在包含它的 那个⽂件中有效，对其他⽂件来说是不可见的，所以便不会导致多重定义。同时，因为这些.cpp⽂件中的该对象都是从⼀个头⽂件中包含进去的，这样也就保证 了这些.cpp⽂件中的这个const对象的值是相同的，可谓⼀举两得。同理，static对象的定义也可以放进头⽂件。
⼆，头⽂件中可 以写内联函数（inline）的定义。因为inline函数是需要编译器在遇到它的地⽅根据它的定义把它内联展开的，⽽并⾮是普通函数那样可以先声明再链 接的（内联函数不会链接），所以编译器就需要在编译时看到内联函数的完整定义才⾏。如果内联函数像普通函数⼀样只能定义⼀次的话，这事⼉就难办了。因为在 ⼀个⽂件中还好，我可以把内联函数的定义写在最开始，这样可以保证后⾯使⽤的时候都可以见到定义；但是，如果我在其他的⽂件中还使⽤到了这个函数那怎么办 呢？这⼏乎没什么太好的解决办法，因此C++规定，内联函数可以在程序中定义多次，只要内联函数在⼀个.cpp⽂件中只出现⼀次，并且在所有的.cpp⽂ 件中，这个内联函数的定义是⼀样的，就能通过编译。那么显然，把内联函数的定义放进⼀个头⽂件中是⾮常明智的做法。
三，头⽂件中可以写类（class）的定义。因为在程序中创建⼀个类的对象时，编译器只有在这个类的定义完全可见的情况下，才能知道这个类的对象应该如何布局，所以，关于类的 定义的要求，跟内联函数是基本⼀样的。所以把类的定义放进头⽂件，在使⽤到这个类的.cpp ⽂件中去包含这个头⽂件，是⼀个
很好的做法。在这⾥，值得⼀提 的是，类的定义中包含着数据成员和函数成员。数据成员是要等到具体的对象被创建时才会被定义（分配空间），但函数成员却是需要在⼀开始就被定义的，这也就 是我们通常所说的类的实现。⼀般，我们的做法是，把类的定义放在头⽂件中，⽽把函数成员的实现代码放在⼀个.cpp⽂件中。这是可以的，也是很好的办法。 不过，还有另⼀种办法。那就是直接把函数成员的实现代码也写进类定义⾥⾯。在C++的类中，如果函数成员在类的定义体中被定义，那么编译器会视这个函数为 内联的。因此，把函数成员的定义写进类定义体，⼀起放进头⽂件中，是合法的。注意⼀下，如果把函数成员的定义写在类定义的头⽂件中，⽽没有写进类定义中， 这是不合法的，因为这个函数成员此时就不是内联的了。⼀旦头⽂件被两个或两个以上的.cpp⽂件包含，这个函数成员就被重定义了。
头⽂件中的保护措施
考虑⼀下，如果头⽂件中只包含声明语句的话，它被同⼀个.cpp⽂件包含再多次都没问题——因为声明语句的出现是不受限制的。然⽽，上⾯讨论到的头⽂件中的 三个例外也是头⽂件很常⽤的⼀个⽤处。那么，⼀旦⼀个头⽂件中出现了上⾯三个例外中的任何⼀个，它再被⼀个.cpp包含多次的话，问题就⼤了。因为这三个 例外中的语法元素虽然“可以定义在多个源⽂件中”，但是“在⼀个源⽂件中只能出现⼀次”。设想⼀下，如果a.h中含有类A的定义，b.h中含有类B的定义，由于类B的定义依赖了类A，所以b.h中也#include了a.h。现在有⼀个源⽂件，它同时⽤到了类A和类B，于是程序员在这个源⽂件中既把 a.h包含进来了，也把b.h包含进来了。这时，问题就来了：类A的定义在这个源⽂件中出现了两次！于是整
个程序就不能通过编译了。你也许会认为这是程序 员的失误——他应该知道b.h包含了a.h——但事实上他不应该知道。
使⽤”#define”配合条件编译可以很好地解决这个问题。在⼀ 个头⽂件中，通过#define定义⼀个名字，并且通过条件编译#ifndef…
#endif使得编译器可以根据这个名字是否被定义，再决定要不要继 续编译该头⽂中后续的内容。这个⽅法虽然简单，但是写头⽂件时⼀定记得写进去。
头⽂件如何来关联源⽂件？
这个问题实际上是说，已知头⽂件“a.h”声明了⼀系列函数(仅有函数原型，没有函数实现)，“b.cpp”中实现了这些函数，那么如果我想在“c.cpp”中使⽤“a.h”中声明的这些在“b.cpp”中实现的函数，通常都是在“c.cpp”中使⽤#include “a.h”，那么c.cpp是怎样到b.cpp中的实现呢？
其实.cpp和.h⽂件名称没有任何直接关系，很多编译器都可以接受其他扩展名。
谭浩强⽼师的《C程序设计》⼀书中提到，编译器预处理时，要对#include命令进⾏“⽂件包含处理”：将headfile.h的全部内容复制到
#include “headfile.h”处。
这也正说明了，为什么很多编译器并不care到底这个⽂件的后缀名是什么—-因为#include预处理就是完成了⼀个“复制并插⼊代码”的⼯作。
程序编译的时候，并不会去b.cpp⽂件中的函数实现，只有在link的时候才进⾏这个⼯作。我们在b.cpp或c.cpp中⽤#include “a.h”实际上是引⼊相关声明，使得编译可以通过，程序并不关⼼实现是在哪⾥，是怎么实现的。源⽂件编译后成⽣了⽬标⽂件（.o或.obj⽂件），⽬标⽂件中，这些函数和变量就视作⼀个个符号。在link的时候，需要在makefile⾥⾯说明需要连接哪个.o或.obj⽂件（在这⾥是b.cpp⽣成的.o或.obj⽂件），此时，连接器会去这个.o或.obj⽂件中在b.cpp中实现的函数，再把他们build到makefile中指定的那个可以执⾏⽂件中。
在VC中，⼀帮情况下不需要⾃⼰写makefile，只需要将需要的⽂件都包括在project中，VC会⾃动帮你把makefile写好。
通常，编译器会在每个.o或.obj⽂件中都去⼀下所需要的符号，⽽不是只在某个⽂件中或者说到⼀个就不了。因此，如果在⼏个不同⽂件中实现了同⼀个函数，或者定义了同⼀个全局变量，链接的时候就会提⽰“redefined”.

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。