下载文档原格式
在头文件声明全局变量和创建extern在头文件声明全局变量和创建extern问题：是否有简单的方法，在头文件里定义我的变量，同时也为它们创建extern定义?回答：是的。
尽管这不是必需的，使用正确的宏和一个头文件还是很容易实现的。
通常，你在C文件中声明一个变量，而在头文件中创建extern定义。
然而，如果你想的话，下面的技巧用来在同一个头文件中声明变量，并且对它们进行extern定义。
首先，创建一个头文件如下（如vars.h)：[cpp]view plaincopyprint?1./*----------------------------------------------------------------------------2.vars.h3.注：在包含vars.h头文件声明和初始化全局变量前面使用 #define VAR_DECLS 1语句。
4.只是包含它，而不定义VAR_DECLS以引用变量。
5.----------------------------------------------------------------------------*/6.#ifndef VAR_DEFS // 保证文件只被包含一次7.#define VAR_DEFS 18./*----------------------------------------------9.设置变量声明宏10.----------------------------------------------*/11.#ifndef VAR_DECLS12.# define _DECL extern13.# define _INIT(x)14.#else15.# define _DECL16.# define _INIT(x) = x17.#endif18./*----------------------------------------------19.声明变量如下：20._DECL [标准变量声明] _INIT(x);21.x是初始化变量的值。
extern变量的用法extern关键字是C语言中常用的一个关键字，用于声明一个全局变量。
与普通的全局变量不同的是，extern关键字用来告诉编译器该变量是在其他文件中定义的，是一个外部变量。
在C 语言中，extern变量的引用和定义都要考虑到其作用域和生存周期的问题。
在C语言中，头文件(.h文件)中常用extern来声明外部变量，然后在源文件(.c文件)中定义这个全局变量。
在其他需要使用该全局变量的源文件中，再通过#include指令包含这个声明的头文件。
extern的作用主要有三个方面：解决多文件共享问题、避免重复定义和提高可维护性。
1. 解决多文件共享问题在C语言中，一个程序通常会由多个源文件组成，每个源文件可以有自己的全局变量。
如果不使用extern，每个源文件都会拥有一个独立的全局变量副本，无法实现数据的共享。
通过使用extern关键字，就可以声明并引用其他源文件中定义的全局变量，实现数据的共享。
例如，我们有两个文件file1.c和file2.c，需要共享一个全局变量count：file1.c：```c#include <stdio.h>extern int count; // 声明外部全局变量void increase();int main() {printf("File 1: count = %d\n", count);increase();printf("File 1: count = %d\n", count);return 0;}```file2.c：```cint count = 10; // 全局变量的定义void increase() {extern int count; // 声明外部全局变量count++;}```上述代码中，file1.c通过extern关键字声明了一个外部全局变量count，然后在main函数中引用了这个变量。
extern 的用法extern是C/C++语言中的关键字，用于告知编译器某个变量、函数或对象的定义存在于其他文件中。
使用extern关键字，可以在当前文件中引用其他文件中定义的变量、函数、对象等。
具体用法如下：1.在当前文件中声明变量的外部引用：当在一个C/C++文件中需要使用其他文件定义的全局变量时，可以使用extern关键字来声明该变量的外部引用。
例如：```c++extern int global_variable; //声明全局变量global_variable 的外部引用```2.在当前文件中声明函数的外部引用：当在一个C/C++文件中需要调用其他文件中定义的函数时，可以使用extern关键字来声明该函数的外部引用。
例如：```c++extern void external_function(); //声明函数external_function的外部引用```3.在头文件中声明共享的全局变量和函数：当多个源文件需要共享同一个全局变量或函数时，可以将其定义在一个头文件中，并在其他源文件中使用extern关键字来声明外部引用。
例如，在header.h 文件中定义了一个全局变量和函数：```c++// header.hextern int shared_variable; //全局变量shared_variable的定义extern void shared_function(); //函数shared_function的定义```然后在其他源文件中使用该头文件并声明外部引用：```c++// main.c#include "header.h"int main() {shared_variable = 10; //使用共享的全局变量shared_function(); //调用共享的函数return 0;}```除了以上用法，还可以进一步拓展extern关键字的用途：-在C++中用于在类的声明中指示函数的定义位于类的外部。
extern变量的用法在 C 语言中，extern 关键字用于声明一个已存在于其他文件中的变量。
这使得我们可以在一个源文件中使用另一个源文件中定义的变量。
这种变量在多个源文件之间的共享和重用是 C 语言编程的一个重要特性。
本文将介绍extern 变量的用法和注意事项。
一、extern 变量的基本用法1. 在头文件中声明变量首先，我们可以在一个头文件中声明一个变量。
例如，我们创建一个名为my_library.h 的头文件，其中包含一个名为my_var 的变量声明：```c// my_library.h#ifndef MY_LIBRARY_H#define MY_LIBRARY_Hint my_var;#endif```在这个例子中，我们声明了一个整型变量my_var。
注意，我们在#ifndef 和#endif 之间定义了我的变量。
这些预处理器指令确保只有在第一次包含my_library.h 时才会对my_var 的声明进行解析。
2. 在源文件中包含头文件并使用变量接下来，我们在一个名为main.c 的源文件中包含my_library.h 头文件并使用my_var 变量：```c// main.c#include <stdio.h>#include "my_library.h"int main() {printf("My variable is set to %d", my_var);return 0;}```在这个例子中，我们包含了stdio.h 头文件以使用printf 函数。
然后，我们包含了my_library.h 头文件，这使得我们在main 函数中可以访问my_var 变量。
编译和运行main.c 文件，我们可以看到my_var 的值被正确打印出来。
二、使用extern 关键字连接变量声明和定义虽然 C 语言允许我们在一个源文件中直接使用另一个源文件中定义的变量，但这种做法可能导致维护困难和不一致的链接。
头文件中一般放一些重复使用的代码，例如函数声明，变量声明，常数定义，宏的定义等等。
当使用＃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时，使用引号(“”)时，首先搜索工程文件所在目录，然后再搜索编译器头文件所在目录。
而使用尖括号(<>)时，刚好是相反的搜索顺序。
C语言头文件的使用第一个C语言程序: Hello world!文件名 First.cmain(){printf(“Hello world!”);}例程-1看看上面的程序，没有.h文件。
是的，就是没有，世界上的万物都是经历从没有到有的过程的，我们对.h的认识，我想也需要从这个步骤开始。
这时确实不需要.h文件，因为这个程序太简单了，根本就不需要。
那么如何才能需要呢？让我们把这个程序变得稍微复杂些，请看下面这个，文件名 First.cprintStr(){printf(“Hello world!”);}main(){printStr()}例程-2还是没有, 那就让我们把这个程序再稍微改动一下.文件名 First.cmain(){printStr()}printStr(){printf(“Hello world!”);}例程-3等等，不就是改变了个顺序嘛, 但结果确是十分不同的. 让我们编译一下例程-2和例程-3,你会发现例程-3是编译不过的.这时需要我们来认识一下另一个C语言中的概念:作用域.我们在这里只讲述与.h文件相关的顶层作用域, 顶层作用域就是从声明点延伸到源程序文本结束, 就printStr()这个函数来说，他没有单独的声明,只有定义,那么就从他定义的行开始,到first.c文件结束, 也就是说,在例程-2的main()函数的引用点上,已经是他的作用域. 例程-3的main()函数的引用点上，还不是他的作用域,所以会编译出错. 这种情况怎么办呢? 有两种方法 ,一个就是让我们回到例程-2, 顺序对我们来说没什么, 谁先谁后不一样呢，只要能编译通过,程序能运行, 就让main()文件总是放到最后吧. 那就让我们来看另一个例程,让我们看看这个方法是不是在任何时候都会起作用.文件名 First.cplay2(){play1()；}play1(){play2()；}main(){play1()；}例程-4也许大部分都会看出来了，这就是经常用到的一种算法, 函数嵌套, 那么让我们看看, play1和play2这两个函数哪个放到前面呢?这时就需要我们来使用第二种方法,使用声明.文件名 First.cplay1();play2();play2(){play1();}play1(){play2(););}main(){play1()}例程--4一个大型的软件项目,可能有几千个,上万个play, 而不只是play1,play2这么简单, 这样就可能有N个类似 play1(); play2(); 这样的声明, 这个时候就需要我们想办法把这样的play1(); play2(); 也另行管理, 而不是把他放在.c文件中, 于是.h文件出现了。
extern的用法"extern" 是 C 和 C++ 语言中的一个关键字，用于声明外部变量和外部函数。
它的主要作用是在一个源文件中引用另一个源文件中定义的变量或函数。
当一个变量或函数在一些源文件中被使用，而其定义却在另一个源文件中时，就需要使用 "extern" 关键字来声明该变量或函数。
这是因为编译器默认情况下只会在当前源文件中查找相应的定义，如果找不到，就会报未定义错误。
为了解决这个问题，我们可以使用 "extern" 来告诉编译器在其他源文件中查找相应的定义。
下面，我们来详细讨论 "extern" 的用法及其在不同上下文中的使用情况。
1.声明全局变量:在一个源文件中声明变量，可以在其他源文件中使用该变量的值。
通常，全局变量的声明放在头文件中，而定义则放在相应的源文件中。
这样，其他源文件只需通过包含头文件即可使用全局变量。
```c// header.h// source1.cint globalVariable = 10;// source2.c#include "header.h"// 可以使用 globalVariable 变量```2.引用全局变量:在一个源文件中使用其他源文件中定义的全局变量，需要在使用之前进行声明。
这样，编译器就知道在其他源文件中查找相应的定义。
```c// source1.cint globalVariable = 10;// source2.c// 可以使用 globalVariable 变量```3.声明外部函数:在一个源文件中声明函数，可以在其他源文件中调用该函数。
同样，函数的声明通常放在头文件中，而定义则放在相应的源文件中。
```c// header.h// source1.cvoid externalFunctio//函数定义}// source2.c#include "header.h"// 可以调用 externalFunction 函数```4.引用外部函数:在一个源文件中调用其他源文件中定义的函数，需要在使用之前进行声明。
extern在c语言中的用法在C语言中，通常将整个程序分为多个源文件来组织代码。
每个源文件可以包含各种函数和变量的定义。
有时候，我们需要在一个源文件中使用另一个源文件中定义的变量或函数。
这时候，就可以使用extern关键字来声明这些外部变量或函数。
1.声明外部变量：当在一个源文件中声明了一些变量，并且该变量可以在其他源文件中使用时，我们就可以使用extern来进行声明。
例如：// 在文件"file1.c"中定义了一个全局变量int global_variable;// 在文件"file2.c"中使用了全局变量在上面的例子中，我们在"file1.c"文件中定义了一个全局变量global_variable，然后在另一个文件"file2.c"中使用了该变量。
为了在"file2.c"文件中使用该变量，我们需要使用extern关键字进行声明。
这样，编译器知道global_variable是在其他文件中定义的。
2.声明外部函数：当在一个源文件中定义了一些函数，并且该函数可以在其他源文件中调用时，我们可以使用extern来进行声明。
例如：// 在文件"file1.c"中定义了一个函数void foo(;// 在其他文件中调用函数foo在上面的例子中，我们在"file1.c"文件中定义了一个函数foo(，然后在其他文件中调用该函数。
为了能够调用foo函数，我们需要使用extern关键字进行声明。
这样，编译器知道foo是在其他文件中定义的。
需要注意的是，extern关键字可以省略。
在声明函数时，如果没有显示使用extern关键字，编译器会默认为函数添加extern关键字；在声明变量时，如果没有显示使用extern关键字，编译器会默认为变量添加extern关键字。
例如：// 在文件"file1.c"中定义了一个全局变量int global_variable;// 在文件"file2.c"中使用了全局变量上面这段代码中，我们在"file1.c"文件中定义了一个全局变量global_variable，然后在文件"file2.c"中使用了该变量。
c语言extern的用法在C语言中，extern关键字用于声明一个全局变量或函数，该变量或函数可以在其他文件中定义和使用。
extern关键字有以下几种常见用法：1. 声明全局变量：在一个文件中使用extern关键字声明一个全局变量，然后在其他文件中定义该变量。
这样可以实现多个文件共享同一个全局变量。
Example：file1.c中：extern int globalVariable; // 声明全局变量file2.c中：int globalVariable = 10; // 定义全局变量2. 声明全局函数：在一个文件中使用extern关键字声明一个全局函数，然后在其他文件中定义该函数。
这样可以实现多个文件共享同一个全局函数。
Example：file1.c中：extern void function(); // 声明全局函数file2.c中：void function() // 定义全局函数{// 函数实现}3. 声明外部变量：在一个文件中使用extern关键字声明一个变量，该变量可以是其他文件中定义的全局变量。
这样可以在当前文件中使用其他文件中定义的全局变量。
Example：file1.c中：extern int globalVariable; // 声明外部变量file2.c中：int globalVariable = 10; // 定义全局变量file3.c中：extern int globalVariable; // 声明外部变量void function(){int localVar = globalVariable; // 使用外部变量// 其他操作}4. 声明外部函数：在一个文件中使用extern关键字声明一个函数，该函数可以是其他文件中定义的全局函数。
这样可以在当前文件中调用其他文件中定义的全局函数。
Example：file1.c中：extern void function(); // 声明外部函数file2.c中：void function() // 定义全局函数{// 函数实现}file3.c中：extern void function(); // 声明外部函数void otherFunction(){function(); // 调用外部函数// 其他操作}。
c语言extern的用法extern是C语言中的一个关键字，可用于修饰变量和函数。
它的主要作用是声明一个全局变量或者函数，以便在其他源文件中使用。
在C语言中，当我们在一个源文件中声明一个全局变量或者函数时，其作用范围仅限于当前源文件。
在其他源文件中想要使用这个全局变量或函数将会报错。
这是因为C语言的编译器在编译的过程中，会首先对每个源文件进行独立的编译，然后再进行链接。
而在链接的过程中，编译器会将各个源文件中的全局变量和函数进行整合，从而产生最终的可执行文件。
因此，在其他源文件中调用未声明的全局变量或函数是非法的。
为了解决这个问题，我们可以使用extern关键字来声明一个全局变量或者函数。
关键字extern用于告诉编译器，我们希望在当前源文件中使用另一个源文件中已经定义的全局变量或函数。
它的基本用法如下：1.声明全局变量：extern int num;在一个源文件中，我们可以这样声明一个全局变量，然后在其他源文件中使用它。
关键字extern告诉编译器，该变量已经在其他源文件中定义过了。
2.声明函数：extern void func(;同样地，在一个源文件中，我们可以这样声明一个函数，然后在其他源文件中调用它。
关键字extern告诉编译器，该函数已经在其他源文件中定义过了。
需要注意的是，extern关键字只是用于声明变量或函数的存在，并不会分配内存空间。
它只是告诉编译器在链接时要去其他源文件中寻找这个变量或函数的定义。
在使用extern关键字时，需要遵循以下几个规则：1.声明和定义：在使用extern关键字时，声明和定义要分开进行。
声明是指告诉编译器变量或函数的存在，定义则是为变量分配内存空间或者定义函数体。
比如，我们在一个源文件中使用extern声明一个全局变量，那么在另一个源文件中需要定义该全局变量。
定义的方式为：int num; // 定义全局变量同样地，如果使用extern声明一个函数，那么在另一个源文件中需要定义该函数。
c语言中extern的用法extern是C语言中的一个关键字，通常用于声明外部的全局变量或函数。
在C语言中，变量或函数可以是内部的（局部的）或外部的（全局的）。
在使用extern关键字时，我们可以在一个文件中声明一个全局变量或函数，然后在另一个文件中使用它，而不需要重新定义。
这样可以使代码更加模块化和可维护。
在C语言中，如果我们想要在多个文件中共享一个全局变量或函数，就需要使用extern关键字。
这样可以避免重复定义同一个变量或函数，提高代码的可读性和可维护性。
在实际的开发过程中，extern关键字经常用于多个源文件之间共享全局变量。
例如，我们可以在一个文件中定义一个全局变量，然后在另一个文件中使用extern来声明它，以便在整个程序中都能够访问这个全局变量。
在C语言中，extern关键字的使用方式比较灵活。
我们可以在变量或函数的声明前面加上extern关键字来声明外部的全局变量或函数，也可以省略extern关键字，直接声明全局变量或函数，其默认行为也是extern。
需要注意的是，使用extern关键字声明的变量或函数必须在某个文件中进行定义，否则会导致编译错误。
因此，在实际编程中，我们需要在某个源文件中定义所有使用extern声明的外部变量或函数，以确保程序能够正常编译和运行。
除了在不同源文件之间共享全局变量或函数外，extern关键字还可以用于在C语言中引用其他模块（如库文件）中定义的全局变量或函数。
这样可以方便我们在程序中使用外部模块提供的功能，同时也能够避免命名冲突。
梳理一下本文的重点，我们可以发现，extern关键字在C语言中起着非常重要的作用，它可以帮助我们实现模块化设计和代码复用，提高程序的可维护性和可扩展性。
通过合理地使用extern关键字，我们可以更加高效地编写C语言程序，减少重复代码的编写，提高开发效率。
因此，在学习和使用C语言时，我们应该深入了解extern关键字的用法和原理，充分利用它来提高编程水平和开发效率。
extern 用法，全局变量与头文件（重复定义）用#include可以包含其他头文件中变量、函数的声明，为什么还要extern关键字,如果我想引用一个全局变量或函数a，我只要直接在源文件中包含#include<xxx.h> (xxx.h包含了a的声明)不就可以了么，为什么还要用extern呢？？这个问题一直也是似是而非的困扰着我许多年了，今天上网狠狠查了一下总算小有所获了：头文件首先说下头文件，其实头文件对计算机而言没什么作用，她只是在预编译时在#include的地方展开一下，没别的意义了，其实头文件主要是给别人看的。
我做过一个实验，将头文件的后缀改成xxx.txt，然后在引用该头文件的地方用#include"xxx.txt"编译，链接都很顺利的过去了，由此可知，头文件仅仅为阅读代码作用，没其他的作用了！不管是C还是C++，你把你的函数，变量或者结构体，类啥的放在你的.c或者.cpp文件里。
然后编译成lib,dll,obj,.o等等，然后别人用的时候最基本的gcc hisfile.cpp yourfile.o|obj|dll|lib 等等。
但对于我们程序员而言，他们怎么知道你的lib,dll...里面到底有什么东西？要看你的头文件。
你的头文件就是对用户的说明。
函数，参数，各种各样的接口的说明。
那既然是说明，那么头文件里面放的自然就是关于函数，变量，类的“声明”了。
记着，是“声明”，不是“定义”。
那么，我假设大家知道声明和定义的区别。
所以，最好不要傻嘻嘻的在头文件里定义什么东西。
比如全局变量：#ifndef _XX_头文件.H#define _XX_头文件.Hint A;#endif那么，很糟糕的是，这里的int A是个全局变量的定义，所以如果这个头文件被多次引用的话，你的A会被重复定义显然语法上错了。
只不过有了这个#ifndef的条件编译，所以能保证你的头文件只被引用一次，不过也许还是会岔子，但若多个c文件包含这个头文件时还是会出错的，因为宏名有效范围仅限于本c源文件，所以在这多个c文件编译时是不会出错的，但在链接时就会报错，说你多处定义了同一个变量，Linking...incl2.obj : error LNK2005: "int glb" (?glb@@3HA) already defined in incl1.objDebug/incl.exe : fatal error LNK1169: one or more multiply defined symbols found注意！！！extern这个关键字真的比较可恶，在声明的时候，这个extern居然可以被省略，所以会让你搞不清楚到底是声明还是定义，下面分变量和函数两类来说：（1）变量尤其是对于变量来说。
extern int a;//声明一个全局变量aint a; //定义一个全局变量aextern int a =0 ;//定义一个全局变量a 并给初值。
int a =0;//定义一个全局变量a,并给初值，第四个等于第三个，都是定义一个可以被外部使用的全局变量，并给初值。
糊涂了吧，他们看上去可真像。
但是定义只能出现在一处。
也就是说，不管是int a;还是extern int a=0;还是int a=0;都只能出现一次，而那个extern int a可以出现很多次。
当你要引用一个全局变量的时候，你就要声明，extern int a;这时候extern不能省略，因为省略了，就变成int a;这是一个定义，不是声明。
（2）函数函数，函数，对于函数也一样，也是定义和声明，定义的时候用extern，说明这个函数是可以被外部引用的，声明的时候用extern说明这是一个声明。
但由于函数的定义和声明是有区别的，定义函数要有函数体，声明函数没有函数体，所以函数定义和声明时都可以将extern省略掉，反正其他文件也是知道这个函数是在其他地方定义的，所以不加extern也行。
两者如此不同，所以省略了extern也不会有问题。
比如：int fun(void){return 0;}很好，我们定义了一个全局函数int fun(void);我们对它做了个声明，然后后面就可以用了加不加extern都一样我们也可以把对fun的声明放在一个头文件里，最后变成这样int fun(void);//函数声明，所以省略了extern，完整些是extern int fun(void);int fun(void){return 0;}//一个完整的全局函数定义，因为有函数体，extern同样被省略了。
然后，一个客户，一个要使用你的fun的客户，把这个头文件包含进去，ok，一个全局的声明。
没有问题。
但是，对应的，如果是这个客户要使用全局变量，那么要extern 某某变量；不然就成了定义了。
总结下：对变量而言，如果你想在本源文件中使用另一个源文件的变量，就需要在使用前用extern声明该变量，或者在头文件中用extern声明该变量；对函数而言，如果你想在本源文件中使用另一个源文件的函数，就需要在使用前用声明该变量，声明函数加不加extern都没关系，所以在头文件中函数可以不用加extern。
C程序采用模块化的编程思想，需合理地将一个很大的软件划分为一系列功能独立的部分合作完成系统的需求，在模块的划分上主要依据功能。
模块由头文件和实现文件组成，对头文件和实现文件的正确使用方法是：规则1头文件(.h)中是对于该模块接口的声明，接口包括该模块提供给其它模块调用的外部函数及外部全局变量，对这些变量和函数都需在.h中文件中冠以extern关键字声明；规则2 模块内的函数和全局变量需在.c文件开头冠以static关键字声明；规则3 永远不要在.h文件中定义变量；许多程序员对定义变量和声明变量混淆不清，定义变量和声明变量的区别在于定义会产生内存分配的操作，是汇编阶段的概念；而声明则只是告诉包含该声明的模块在连接阶段从其它模块寻找外部函数和变量。
如：int a = 5;#include “module1.h”#include “module1.h”#include “module1.h”以上程序的结果是在模块1、2、3中都定义了整型变量a，a在不同的模块中对应不同的地址单元，这明显不符合编写者的本意。
正确的做法是：extern int a;#include “module1.h”int a = 5;#include “module1.h”#include “module1.h”这样如果模块1、2、3操作a的话，对应的是同一片内存单元。
规则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的长度了。
为了在几个源文件中共享变量i，首先把变量i的定义放置在一个文件中：int i;如果需要对变量i初始化，那么可以在这里放初始值。
在编译这个文件时，编译器将会为变量i分配内存空间，而其他文件将包含变量i的声明：extern int i;通过在每个文件中声明变量i，使得在这些文件中可以访问/或修改变量i。
然而，由于关键字extern，使得编译器不会在每次编译其中某个文件时为变量i分配额外的内存空间。
当在文件中共享变量时，会面临和共享函数时相似的挑战：确保变量的所有声明和变量的定义一致。
为了避免矛盾，通常把共享变量的声明放置在头文件中。
需要访问特殊变量的源文件可以稍后包含适当的头文件。
此外，含有变量定义的源文件包含每一个含有变量声明的头文件，这样使编译器可以检查两者是否匹配。
如果工程很大，头文件很多，而有几个头文件又是经常要用的，那么1。
把这些头文件全部写到一个头文件里面去，比如写到preh.h2。
写一个preh.c，里面只一句话：#include "preh.h"3。
对于preh.c，在project setting里面设置creat precompiled headers，对于其他c文件，设置use precompiled header file。
