extern用法 全局变量与头文件
在头文件声明全局变量和创建extern
在头文件声明全局变量和创建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是初始化变量的值。
c extern 变量
c extern 变量摘要：一、C语言中extern变量的概念1.extern关键字的作用2.全局变量与局部变量的区别二、extern变量的使用规则1.声明extern变量的方式2.使用extern变量的方式3.extern变量的作用范围三、extern变量的应用实例1.模块化编程2.文件间的变量传递正文：C语言是一种支持多文件的编程语言，这就涉及到如何在不同的文件中使用相同的变量。
为了解决这个问题，C语言引入了extern关键字。
下面将从extern变量的概念、使用规则和应用实例三个方面进行详细介绍。
一、C语言中extern变量的概念在C语言中，extern关键字用于声明一个变量是在本文件之外定义的，或者说是全局变量。
使用extern关键字可以让其他文件访问这个变量。
它告诉编译器，该变量在其他文件中已经声明过，因此不需要再重复声明。
这样可以减少代码冗余，提高程序的可维护性。
需要注意的是，extern变量与局部变量是不同的。
局部变量是在函数内部定义的变量，其作用范围仅限于函数内部，不能被其他函数或文件访问。
而extern变量可以在整个程序范围内访问。
二、extern变量的使用规则1.声明extern变量的方式要声明一个extern变量，只需在变量定义之前加上extern关键字。
例如：```cextern int global_var;```这样声明的global_var就是一个extern变量，其他文件可以通过这个声明来访问它。
2.使用extern变量的方式使用extern变量时，只需像使用普通变量一样进行声明和访问。
例如：```c// 文件1extern int global_var;int main() {global_var = 10;return 0;}// 文件2int global_var;int main() {printf("global_var = %d", global_var);return 0;}```在这个例子中，文件1和文件2都声明了一个名为global_var的extern 变量。
extern变量的用法
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 的用法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变量的用法
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 语言允许我们在一个源文件中直接使用另一个源文件中定义的变量，但这种做法可能导致维护困难和不一致的链接。
c语言中头文件的-函数-全局变量-extern
头文件中一般放一些重复使用的代码，例如函数声明，变量声明，常数定义，宏的定义等等。
当使用＃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在c语言中的作用
extern在c语言中的作用在C语言中，通常将函数定义、变量定义等放在头文件中，然后通过extern关键字在源文件中引用这些定义，以便在编译时能够正确地链接相关的定义。
以下是extern在C语言中的主要用法和作用：1. 声明外部函数：当函数定义在其他文件中时，可以使用extern关键字来声明该函数，以便在当前文件中引用该函数。
例如：int maiint result = add(5, 2);return 0;}这样，编译器就能找到并正确链接add函数的定义。
2. 声明外部全局变量：当全局变量定义在其他文件中时，可以使用extern关键字来声明该全局变量，以便在当前文件中引用该全局变量。
例如：int maiglobalVar = 10;return 0;}这样，编译器就能找到并正确链接globalVar的定义。
注意：extern关键字只是声明，不能用于定义变量。
在其他文件中已经定义过的全局变量，不需要再使用extern关键字声明。
3. 引用其他文件的头文件：在C语言中，通常将函数的声明放在头文件中，然后在源文件中使用extern关键字引用该头文件以获得函数的声明。
例如：#include "myheader.h"int maiint result = add(5, 2);return 0;}这里myheader.h头文件中包含了add函数的声明，使用extern关键字引用该头文件，以便在编译时可以找到add函数的声明。
4. 声明全局变量的作用范围：通过在函数外部使用extern关键字声明全局变量，可以将该全局变量的作用范围扩大到整个程序中的其他文件。
例如：// file1.cint globalVar;// file2.cint maiglobalVar = 10;return 0;}这样，file2.c文件中的main函数就能访问并修改file1.c文件中定义的globalVar变量。
C语言中extern的用法
C语言中extern的用法在C语言中，修饰符extern用在变量或者函数的声明前，用来说明“此变量/函数是在别处定义的，要在此处引用”。
1. extern修饰变量的声明。
举例来说，如果文件a.c需要引用b.c中变量int v，就可以在a.c中声明extern int v，然后就可以引用变量v。
这里需要注意的是，被引用的变量v 的链接属性必须是外链接（external）的，也就是说a.c要引用到v，不只是取决于在a.c 中声明extern int v，还取决于变量v本身是能够被引用到的。
这涉及到c语言的另外一个话题－－变量的作用域。
能够被其他模块以extern修饰符引用到的变量通常是全局变量。
还有很重要的一点是，extern int v可以放在a.c中的任何地方，比如你可以在a.c中的函数fun定义的开头处声明extern int v，然后就可以引用到变量v了，只不过这样只能在函数fun作用域中引用v罢了，这还是变量作用域的问题。
对于这一点来说，很多人使用的时候都心存顾虑。
好像extern声明只能用于文件作用域似的。
2. extern修饰函数声明。
从本质上来讲，变量和函数没有区别。
函数名是指向函数二进制块开头处的指针。
如果文件a.c需要引用b.c中的函数，比如在b.c中原型是int fun(int mu)，那么就可以在a.c中声明extern int fun（int mu），然后就能使用fun来做任何事情。
就像变量的声明一样，extern int fun（int mu）可以放在a.c中任何地方，而不一定非要放在a.c的文件作用域的范围中。
对其他模块中函数的引用，最常用的方法是包含这些函数声明的头文件。
使用extern和包含头文件来引用函数有什么区别呢？extern的引用方式比包含头文件要简洁得多！extern的使用方法是直接了当的，想引用哪个函数就用extern 声明哪个函数。
这大概是KISS原则的一种体现吧！这样做的一个明显的好处是，会加速程序的编译（确切的说是预处理）的过程，节省时间。
extern的用法
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语言中的用法
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"中使用了该变量。
关于extern声明全局变量的用法
int i =5；
若想在文件file2也使用这个变量，就可以如下：
file2
extern int i; //此时，编译器就知道i是一个已在其他地方定义的变量，会自动在本文件
//或其他文件中搜寻
i=6; //声明之后，就可在file2中对变量操作
这篇文章主要讲解一下extern声明全局变量的一些用法，虽然知识点比较浅显，但是却容易犯错，仅与那些初学C++的朋友分享，希望没有让大牛们见笑。
extern最基本的用法是声明全局变量的。这里需要注意两点，一是“声明”，二是“全局变量”；我们先来分析这两个概念。
声明：声明和定义是有区别的。声明不等于定义，声明只是指出了变量的名字，并没有为其分配存储空间；定义指出变量名字同时为变量分配存储空间，定义包含了声明。例如：
注意：这种使用对于const变量是个例外。Const类型变量默认为当前文件的局部变量，即便在其他文件中声明了也不能使用。要想在其他文件中使用，定义const类型变量时必须在前面显式指出是extern。例如：
file1：
extern const int i=5;
此时就能在其他文件中声明并使用了。具体这反面的原因和头文件的使用有关，这里就不详述了。
{
extern int i; //声明之后，变量i的作用域从该处开始直到文件结束。
cout<<i<<endl;
return 0;
}
int i=5;
使用：在实际编程中，有时程序需要包含多个源文件，若这些文件有共同使用的变量，那么这个变量就遵循“一次定义，多次声明”的形式。即在一个文件中定义，其他文件使用时先进行声明。例如在文件file1中定义了一个变量：
c语言extern的用法
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的用法
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声明一个函数，那么在另一个源文件中需要定义该函数。
extern在c语言用法
extern在c语言用法摘要：1.介绍C 语言中的"extern"关键字2."extern"在C 语言中的用法3.示例：使用"extern"定义全局变量和函数正文：一、介绍C 语言中的"extern"关键字在C 语言中，"extern"是一个关键字，用于声明外部变量或函数。
外部变量或函数指的是在当前源文件之外定义的变量或函数，通常位于其他源文件中。
使用"extern"关键字可以避免重复定义变量或函数，同时提高程序的可读性和可维护性。
二、"extern"在C 语言中的用法1.使用"extern"定义全局变量在C 语言中，我们可以使用"extern"关键字定义全局变量。
全局变量是在程序的整个生命周期内都可以访问的变量。
当一个源文件中定义了一个全局变量，其他源文件可以通过使用"extern"关键字来访问这个全局变量。
示例：```c// file1.cextern int global_var;int global_var = 10;// file2.c#include <stdio.h>extern int global_var;int main() {printf("Global variable value: %d", global_var);return 0;}```2.使用"extern"定义函数同样，在C 语言中，我们也可以使用"extern"关键字定义函数。
当一个源文件中定义了一个函数，其他源文件可以通过使用"extern"关键字来访问这个函数。
示例：```c// file1.cextern void my_function(int x, int y);void my_function(int x, int y) {printf("x + y = %d", x + y);}// file2.c#include <stdio.h>extern void my_function(int x, int y);int main() {my_function(3, 4);return 0;}```三、总结通过使用"extern"关键字，我们可以在C 语言中定义外部变量和函数，提高程序的可读性和可维护性。
c语言中extern的用法
c语言中extern的用法1. 引言C语言中的extern关键字是一个非常重要的关键字，它用于声明一个全局变量或函数，以便在其他文件中使用。
extern关键字的使用方式非常灵活，可以在不同的场景中发挥不同的作用。
本文将深入研究C语言中extern关键字的用法，探讨其在不同情况下的应用和作用。
2. extern声明全局变量在C语言中，全局变量是定义在函数外部、文件内部的变量。
如果我们希望在其他文件中使用该全局变量，则需要使用extern关键字进行声明。
通过extern声明全局变量，我们可以将其引入到其他文件，并且可以通过该外部引用进行访问和修改。
3. extern声明函数除了可以通过extern声明全局变量外，我们还可以使用它来声明函数。
当我们希望在某个文件中调用另一个文件定义的函数时，需要先通过extern进行函数声明。
这样，在编译时就能够知道该函数存在，并且能够正确地调用它。
4. extern与头文件头文件是C语言编程中常见且重要的概念之一。
它通常包含了一些常见类型定义、宏定义和函数声明等信息。
当我们需要在多个源文件之间共享这些信息时，就需要使用头文件来实现。
通过将相关信息放入头文件中，并在需要使用的源文件中使用#include指令引入头文件，我们可以在不同的源文件中共享同样的定义和声明。
在头文件中，我们可以使用extern关键字来声明全局变量和函数，以便在其他源文件中使用。
5. extern与多文件编译多文件编译是C语言开发中常见的一种方式。
通过将程序分割成多个源文件，可以提高代码的可读性和可维护性。
然而，在多个源文件之间共享变量和函数是一项挑战。
通过使用extern关键字，我们可以在不同的源文件之间共享全局变量和函数。
通过在一个源文件中定义变量或函数，并将其声明为extern，在其他需要使用该变量或函数的源文件中进行引用，就能够实现跨源文件共享。
6. extern与静态全局变量静态全局变量是指定义在函数外部、仅能被本地代码访问的全局变量。
extern的用法
extern的用法extern是一个C/C++语言中重要的关键词，它用于声明全局变量和函数。
在C语言中，extern用于在不同文件之间共享变量和函数，而在C++语言中则用于声明一个变量或函数在其它文件中定义。
本文将重点介绍extern的用法及其在不同语言之间的应用。
一、用法1、在C语言中，extern用于声明全局变量和函数，即在不同文件之间共享变量和函数，方式如下：在需要共享的变量或函数所在的文件中，以下为其声明：int g_i = 10; //局变量声明int add(int a, int b); //数声明在使用该变量或函数的文件中，以下为extern声明：extern int g_i; //局变量声明extern int add(int a, int b); //数声明2、在C++语言中，extern用于声明一个变量或函数在其它文件中定义，方式如下：在需要共享的变量或函数所在的文件中，以下为其声明：extern int g_i = 10; //局变量声明extern int add(int a, int b); //数声明在使用该变量或函数的文件中，以下为其声明：extern int g_i; //局变量声明extern int add(int a, int b); //数声明二、在不同语言中的应用1、在C语言中，extern可以用来在一个函数中声明另一个函数，以便在该函数内部调用，如：//明函数int add(int a, int b);//义函数int sum(int a, int b){extern int add(int, int); //明函数return add(a, b); //用函数}2、在C++语言中，extern可以用来在类中声明类的静态成员，如：//义类class Foo{public:static int g_i; //态成员变量static int add(int a, int b); //态成员函数};//类实现文件中，声明类的静态成员extern int Foo::g_i;extern int Foo::add(int a, int b);三、总结extern是一个C/C++语言中重要的关键词，它用于声明全局变量和函数，在C语言中用于在不同文件之间共享变量和函数，而在C++语言中用于声明一个变量或函数在其它文件中定义。
extern的使用
extern的使用在C语言中，extern是一个关键字，它用于声明一个变量或函数是在其他地方定义的。
它的作用是告诉编译器，在该文件中不需要为这个变量或函数分配内存空间，而是在其他文件中进行定义和分配。
在实际编程中，extern通常用于解决多文件之间的变量或函数的引用问题。
在一个文件中定义的全局变量或函数，在其他文件中如果要使用，就需要通过extern进行引用。
这样可以让编译器知道该变量或函数是在其他文件中定义的，编译器在编译时会去查找这个变量或函数的定义。
在使用extern时，需要注意以下几点：1. 声明变量：当一个全局变量在一个文件中定义后，其他文件如果要使用该变量，就需要在使用前先用extern进行声明。
例如，在文件A中定义了一个全局变量int num，其他文件B要使用这个变量，就需要在文件B中使用extern int num进行声明。
2. 声明函数：当一个函数在一个文件中定义后，其他文件如果要使用该函数，也需要在使用前先用extern进行声明。
例如，在文件A 中定义了一个函数void func()，其他文件B要使用这个函数，就需要在文件B中使用extern void func()进行声明。
3. 多文件编译：如果我们的程序分成了多个文件进行编写，每个文件都有自己的变量或函数，并且这些变量或函数需要在其他文件中使用，就需要用extern进行声明。
在编译时，需要将所有的文件一起进行编译链接。
4. 变量和函数：extern可以用于声明变量和函数。
对于变量，使用extern只是声明了变量，没有分配内存空间；对于函数，使用extern只是声明了函数，没有定义函数体。
5. 多个文件中的同名变量：当多个文件中有同名的全局变量时，使用extern可以指定使用哪个文件中的变量。
通过在变量声明时加上extern关键字，可以明确指定使用哪个文件中的变量。
总结一下，extern是C语言中用于声明一个变量或函数是在其他地方定义的关键字。
extern在c语言用法
extern在c语言用法以下是关于C语言中extern关键字的用法的一篇文章。
一、引言在C语言中，extern关键字被用来声明在其他源文件中定义的全局变量或函数。
通过使用extern关键字，我们可以在一个源文件中引用另一个源文件中定义的全局变量或函数，从而实现模块化的编程。
本文将详细介绍extern关键字的用法，并通过一些示例来说明其具体应用。
二、全局变量的声明与定义在介绍extern关键字之前，我们首先需要了解全局变量的声明和定义的概念。
全局变量是在函数外部定义的变量，可以在整个程序中被访问和使用。
在一个C 程序中，全局变量通常在头文件中进行声明，而在源文件中进行定义。
例如，我们有一个头文件global.h，其中声明了一个全局变量count：Cextern int count;而在另一个源文件main.c中，我们对全局变量count进行了定义：Cint count = 0;这样，我们就在全局范围内声明并定义了一个全局变量count。
注意到在头文件中的声明中使用了extern关键字，以示该变量在其他源文件中定义。
三、使用extern关键字引用全局变量在一个源文件中，如果我们需要引用另一个源文件中定义的全局变量，我们可以使用extern关键字来实现。
通过使用extern关键字，编译器将知道我们引用的是其他源文件中定义的全局变量，而不是在当前源文件中定义的局部变量。
例如，我们在另一个源文件test.c中需要引用main.c中定义的全局变量count。
我们只需在test.c中对全局变量count进行声明，而无需进行定义：Cextern int count;这样，我们就可以在test.c中使用全局变量count了。
编译器会在链接阶段将count的实际定义与引用处进行连接。
四、函数的声明与定义与全局变量类似，函数也可以通过extern关键字进行声明和定义。
函数的声明通常在头文件中进行，而定义在源文件中进行。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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。