C语言extern使用方法总结
c语言中extern的详细用法解析
一、extern关键字的概述在C语言中，extern是一个关键字，它用来引用外部变量或者函数。
extern关键字告诉编译器，所描述的变量或函数是在其他地方定义的，并且要在当前文件中使用。
extern关键字可以用于在文件之间共享变量，也可以用于访问全局变量。
二、extern关键字的用法1. 引用外部全局变量在C语言中，如果想要在一个文件中引用其他文件中定义的全局变量，可以使用extern关键字。
例如：```cextern int global_var;```这样就可以在当前文件中使用其他文件中定义的global_var变量。
2. 外部函数的声明在C语言中，如果想要在一个文件中引用其他文件中定义的函数，可以使用extern关键字进行声明。
例如：```cextern void function_name();```这样就可以在当前文件中使用其他文件中定义的function_name函数。
3. 使用extern关键字的注意事项在使用extern关键字时，需要注意以下几点：- 在声明变量或函数时，不要给出变量或函数的具体实现，只需声明其存在即可。
- 声明时的数据类型、函数参数列表要和实际实现一致，以确保在信息时能够正确匹配。
- 只能在全局作用域和函数的外部使用extern关键字。
在函数内部使用extern是无效的。
三、extern关键字的示例下面通过一个示例来展示extern关键字的用法：```c// file1.c#include <stdio.h>int global_var = 10;void function_name();int m本人n() {printf("The value of global_var is: d\n", global_var);function_name();return 0;}``````c// file2.c#include <stdio.h>extern int global_var; // 声明外部全局变量void function_name() {printf("This is an external function\n");printf("The value of global_var is: d\n", global_var);}```在这个例子中，file1.c文件中定义了一个全局变量global_var和一个m本人n函数，而file2.c文件中使用extern关键字声明了global_var和function_name函数。
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++中用于在类的声明中指示函数的定义位于类的外部。
c语言extern用法
c语言extern用法C语言中的extern关键字是一个非常重要的关键字，它可以用来声明一个变量或函数是在其他文件中定义的。
在C语言中，当我们需要在一个文件中使用另一个文件中定义的变量或函数时，我们需要使用extern关键字来声明这个变量或函数。
在C语言中，extern关键字的用法有两种，分别是extern变量和extern函数。
1. extern变量在C语言中，如果我们需要在一个文件中使用另一个文件中定义的变量，我们需要使用extern关键字来声明这个变量。
例如，我们在文件A中定义了一个变量x，我们需要在文件B中使用这个变量，我们可以在文件B中使用extern关键字来声明这个变量：```// 文件Aint x = 10;// 文件Bextern int x;```这样，在文件B中就可以使用变量x了。
需要注意的是，extern关键字只是声明了这个变量，它并没有定义这个变量。
因此，在使用这个变量之前，我们需要在程序中定义这个变量。
2. extern函数在C语言中，如果我们需要在一个文件中使用另一个文件中定义的函数，我们也需要使用extern关键字来声明这个函数。
例如，我们在文件A中定义了一个函数add，我们需要在文件B中使用这个函数，我们可以在文件B中使用extern关键字来声明这个函数：```// 文件Aint add(int a, int b) {return a + b;}// 文件Bextern int add(int a, int b);```这样，在文件B中就可以使用函数add了。
需要注意的是，extern 关键字只是声明了这个函数，它并没有定义这个函数。
因此，在使用这个函数之前，我们需要在程序中定义这个函数。
总结在C语言中，extern关键字是一个非常重要的关键字，它可以用来声明一个变量或函数是在其他文件中定义的。
在使用extern关键字时，需要注意声明和定义的区别，以及在使用之前需要先定义。
extern 用法
extern 用法在C语言中，extern 是一个关键字，它用于声明变量或函数是在其他文件或模块中定义的。
这是一种在不同文件之间共享变量和函数的方法，它可以让我们将程序划分为多个模块，并且可以在不同的模块中使用相同的变量和函数。
本文将介绍 extern 的用法和一些实际应用场景。
1. extern 变量当我们在一个文件中声明一个变量时，如果该变量是在另一个文件中定义的，我们需要使用 extern 关键字来告诉编译器该变量是在其他文件中定义的。
例如，在文件 a.c 中定义了一个变量 x： ```int x = 10;```在文件 b.c 中使用该变量时，我们需要在 b.c 中声明该变量：```extern int x;```这告诉编译器变量 x 是在其他文件中定义的，编译器会在链接时将 x 的实际地址与使用它的代码关联起来。
2. extern 函数与变量类似，如果我们在一个文件中调用一个函数，而该函数是在另一个文件中定义的，我们需要使用 extern 关键字来告诉编译器该函数是在其他文件中定义的。
例如，在文件 a.c 中定义了一个函数 foo：```void foo() {printf('Hello, world!');}```在文件 b.c 中调用该函数时，我们需要在 b.c 中声明该函数：```extern void foo();```这告诉编译器函数 foo 是在其他文件中定义的，编译器会在链接时将函数 foo 的实际地址与调用它的代码关联起来。
3. extern 变量和函数的实际应用在实际编程中，我们通常将程序划分为多个模块，每个模块负责不同的任务。
这种模块化的设计使程序更易于维护和扩展。
而extern 关键字可以让我们在不同的模块之间共享变量和函数，从而更加灵活地组织程序。
例如，我们可以将一个大型程序划分为多个模块，每个模块负责不同的任务，如下所示：```// module1.cint x = 10;// module2.cvoid foo() {printf('Hello, world!');}// main.cextern int x;extern void foo();int main() {printf('x = %d', x);foo();return 0;}```在这个例子中，我们将程序划分为三个模块：module1.c、module2.c 和 main.c。
extern用法举例c++
extern用法举例c++一、概述extern是C语言中一个非常重要的关键字，它用于声明变量或函数在别的文件中存在，或者在程序运行时从别的文件中加载。
本文将通过一些具体的例子来介绍extern的用法。
二、变量声明1. 声明在别的文件中：如果我们将一个变量定义放在一个文件中，那么其他文件就不能使用这个变量。
但是，如果我们使用extern关键字，就可以在其他文件中引用这个变量。
例如：在文件a.c中：```cint var; // 定义变量var```在文件b.c中：```cextern int var; // 声明变量var在其他文件中存在```此时，b.c中的代码就可以使用变量var了。
2. 声明在程序运行时：如果变量或函数是在程序运行时加载的，那么我们也可以使用extern关键字来引用它。
例如，如果我们有一个全局变量，但是想要在程序运行时动态加载它，那么可以使用extern关键字来引用它。
例如：在文件main.c中：```cextern int globalVar; // 声明全局变量在其他文件中存在```在文件loader.c中：```cint globalVar = 42; // 在运行时动态加载全局变量```此时，main.c中的代码就可以使用全局变量globalVar了。
三、函数声明1. 声明在别的文件中：如果我们将一个函数定义放在一个文件中，那么其他文件就不能调用这个函数。
但是，如果我们使用extern关键字，就可以在其他文件中引用这个函数。
例如：在文件a.c中：```cvoid func() { // 定义函数func// 函数实现代码}```在文件b.c中：```cextern void func(); // 声明函数func在其他文件中存在```此时，b.c中的代码就可以调用函数func了。
需要注意的是，函数的声明应该放在调用它的代码之前。
否则会出现编译错误。
2. 声明在程序运行时：如果函数是在程序运行时加载的，也可以使用extern关键字来引用它。
extern用法
extern用法extern法是一个重要的C语言语法，主要用于向其他文件共享变量或函数。
extern法在多个文件中可以定义全局变量和函数，从而使程序组织更加清晰，让程序变得更强壮。
extern法可以定义两种类型的变量：(1)变量的指针;(2)extern 的变量。
extern的变量指的是变量的存在有效期一般为整个程序 (进程)执行，而变量指针则是指向extern变量的指针，它表示指针指向的变量是在程序外部定义的。
extern法主要有三种用途：1. extern法可以定义变量或函数为全局变量或函数，使得它们可以被多个文件使用，而不需要每次都重复定义。
2. extern法可以用来定义指向其他文件中定义的变量或函数的指针，从而实现对这些变量或函数的访问和调用。
3. extern法还可以用来定义宏和其他符号，以便在多个文件中使用。
extern法的语法是：extern [type] [name]，其中type指的是变量的类型，name则是变量的名字，extern可以加到变量定义语句的开头，也可以加到变量声明语句的开头。
extern用法定义的变量只能在文件内部使用，而extern用法定义的全局变量则可以在其他文件中使用，但是在这种情况下，调用的文件必须先包含extern定义的文件，也就是必须先include extern 定义文件，如果没有包含，那么就会出错。
extern用法的好处非常多，它可以让变量在多文件中共享，而不需要重复定义，它还可以把大型程序分解为多个文件，从而使程序更加有条理、易于管理。
extern用法也可以定义全局变量，从而可以使得多个程序共享数据，对于大型应用来说，extern用法是十分重要的。
extern用法的缺点也很明显，它使得程序的维护变得更加困难，因为程序的变量和函数可能在多个文件中定义，如果要查找某个变量或函数的定义，就需要搜索整个程序，这会让程序变得非常复杂，而且程序的执行效率也会受到影响。
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原则的一种体现吧！这样做的一个明显的好处是，会加速程序的编译（确切的说是预处理）的过程，节省时间。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
extern使用方法总结！作者：VIP用户提交日期：2007-5-16 20:53:00Extern的问题在于不知道这个关键词出现的时候到底是声明还是定义。
谨记：声明可以多次，定义只能一次。
函数的声明extern关键词是可有可无的，因为函数本身不加修饰的话就是extern的。
但是引用的时候一样是需要声明的。
而全局变量在外部使用声明时，extern关键词是必须的，如果变量无extern修饰且没有显式的初始化，同样成为变量的定义，因此此时必须加extern，而编译器在此标记存储空间在执行时加载如内存并初始化为0。
而局部变量的声明不能有extern的修饰，且局部变量在运行时才在堆栈部分分配内存。
引用性声明、定义性声明强符号、弱符号出现在linux的gcc链接分析中，可以加深链接的理解。
全局变量或函数本质上讲没有区别，函数名是指向函数二进制块开头处的指针。
而全局变量是在函数外部声明的变量。
函数名也在函数外，因此函数也是全局的。
在使用中，要形成一种风格。
头文件首先说下头文件，其实头文件对计算机而言没什么作用，她只是在预编译时在#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。
声明（Declaration）用于说明每个标识符的含义，而并不需要为每个标识符预存储空间。
预留存储空间的声明称为定义（Definition）。
声明的形式为：声明说明符声明符声明符是由存储类说明符和类型说明符组成的。
1、变量的声明有两种情况：一种是需要建立存储空间的。
例如：int a 在声明的时候就已经建立了存储空间。
2、另一种是不需要建立存储空间。
例如：extern int a 其中变量a是在别的文件中定义的。
例一：Declaration.A construct which associates attributes to a variable name or function. No storage is reserved. For example:extrn int a;extrn char c;variable declaration A structure decleration could look like:Definition.Variable definition is a declaration with storage allocation.example a function definition would be:前者是"定义性声明(defining declaration)"或者称为"定义(definition)",而后者是"引用性声明(referncing declaration)" 。
从广义的角度来讲声明中包含着定义，但是并非所有的声明都是定义，例如：int a 它既是声明，同时又是定义。
然而对于extern a 来讲它只是声明不是定义。
它可以在同一源程序或不同的源程序中重复声明。
一般的情况下我们常常这样叙述，把建立空间的声明称之为"定义"，而把不需要建立存储空间称之为"声明"。
很明显我们在这里指的声明是范围比较窄的，也就是说非定义性质的声明。
例如：在主函数中看来定义还是声明有时与编译器的处理也有关系。
外部变量的"定义"与外部变量的"声明"是不相同的,外部变量的定义只能有一次，它的位置是在所有函数之外，而同一个文件中的外部变量声明可以是多次的，它可以在函数之内(哪个函数要用就在那个函数中声明)也可以在函数之外(在外部变量的定义点之前)。
系统会根据外部变量的定义(而不是根据外部变量的声明)分配存储空间的。
对于外部变量来讲，初始化只能是在"定义"中进行,而不是在"声明"中。
所谓的"声明"，其作用，是声明该变量是一个已在后面定义过的外部变量，仅仅是在为了"提前"引用该变量而作的"声明"而已。
extern 只作声明，不作任何定义。
用static来声明一个变量的作用有二：(1) 对于局部变量用static声明，则是为该变量分配的空间在整个程序的执行期内都始终存在。
(2) 外部变量用static来声明，则该变量的作用只限于本文件模块。
#include "stdafx.h"1.extern用在变量声明中常常有这样一个作用，你在*.c文件中声明了一个全局的变量，这个全局的变量如果要被引用，就放在*.h中并用extern来声明。
2.如果函数的声明中带有关键字extern，仅仅是暗示这个函数可能在别的源文件里定义，没有其它作用。
即下述两个函数声明没有区别：extern int f(); 和int f();＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝如果定义函数的c/cpp文件在对应的头文件中声明了定义的函数，那么在其他c/cpp文件中要使用这些函数，只需要包含这个头文件即可。
如果你不想包含头文件，那么在c/cpp中声明该函数。
一般来说，声明定义在本文件的函数不用“extern”，声明定义在其他文件中的函数用“extern”，这样在本文件中调用别的文件定义的函数就不用包含头文件include “*.h”来声明函数，声明后直接使用即可。
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝举个例子：//extern.cpp内容如下：// extern.cpp : Defines the entry point for the console application.//#include "s t dafx.h"extern print(char *p);int main(int argc, char* argv[]){char *p="hello world!";print(p);return 0;}//print.cpp内容如下#include "stdafx.h"#include "stdio.h"print(char *s){printf("The string is %s\n",s);}结果程序可以正常运行，输出结果。