c++多个源文件共用一个全局变量(extern 的用法)
extern修饰变量或函数时的作用。
extern修饰变量或函数时的作用。
在编程中，extern是一个关键字，用于修饰变量或函数，其作用是告诉编译器该变量或函数是在其他地方定义的，需要在当前文件中引用。
通过使用extern关键字，可以实现多个文件之间的变量或函数共享，提高代码的可维护性和可扩展性。
一、extern修饰变量的作用在C语言中，extern可以用于修饰全局变量，以便在不同的文件中共享该变量。
当某个文件需要使用其他文件中定义的全局变量时，可以使用extern关键字来声明该变量，从而在当前文件中引用其他文件中定义的全局变量。
例如，假设有两个文件a.c和b.c，其中a.c定义了一个全局变量num：```c// a.c文件int num = 10;```如果在b.c文件中需要使用a.c中定义的全局变量num，可以在b.c 中使用extern关键字声明该变量：```c// b.c文件extern int num;```通过使用extern关键字声明num变量，b.c文件就可以使用a.c中定义的全局变量num了。
这样，不同的文件就可以共享同一个全局变量，实现了变量的跨文件共享。
二、extern修饰函数的作用在C语言中，extern还可以用于修饰函数，以便在不同的文件中共享该函数。
当某个文件需要调用其他文件中定义的函数时，可以使用extern关键字来声明该函数，从而在当前文件中引用其他文件中定义的函数。
例如，假设有两个文件a.c和b.c，其中a.c定义了一个函数add：```c// a.c文件int add(int a, int b) {return a + b;}```如果在b.c文件中需要调用a.c中定义的函数add，可以在b.c中使用extern关键字声明该函数：```c// b.c文件extern int add(int a, int b);```通过使用extern关键字声明add函数，b.c文件就可以调用a.c中定义的函数add了。
多个c文件共享同一个变量（全局变量）
多个c⽂件共享同⼀个变量（全局变量）记得还是⼤⼆的时候，只会if else 这些，所有的代码都是在同⼀个main.c⽂件中这是何等的搞笑啊，现在想想都觉得好笑，不过很开⼼我现在终于会把⾃⼰写的东西保存起来，因为没准哪天会⽤到，毕竟⾃⼰写的，⾃⼰知道怎么去改，既然当了程序员，那么就要将基础学好咯，以上都是废话。
This is a 华丽的分割线----------------多个源⽂件共享同个变量的⽅法当然就是extern关键字了extern：extern可置于变量或者函数前，以表⽰变量或者函数的定义在别的⽂件中，提⽰编译器遇到此变量和函数时在其他模块中寻找其定义。
另外，extern也可⽤来进⾏链接指定。
现做如下解释：我们可以在⼀个变量前加⼀个extern⽐如：extern unsigned int Test；那么加上这句话之后，编译器编译的时候（别问我编译是什么意思）会把Test当成是外部的！会在其他地⽅寻找Test这个变量的定义，如果你只加了个extern那么编译器就会报错滴！⽐如这样：1>main.obj : error LNK2001: ⽆法解析的外部符号 "int Test" (?Test@@3HA)1>E:\wtl\test\test\Debug\test.exe : fatal error LNK1120: 1 个⽆法解析的外部命令那么就说明，其实我们这个extern关键字只是说明我们从外部引⽤了⼀个变量，该变量的值叫Test，提醒编译器要到其他⽂件中查找该变量！要想不报错，在其他⽂件加个int Test 定义⼀个名字叫Test的变量吧。
这样就能编译通过啦，貌似有点离题。
表紧！我们赶紧回头，那么假设我有个main.c，source1.c，source2.c那么我想要在main⾥⾯定义⼀个变量，在source1.c跟source2.c都能使⽤该如何做？很简单，先在main.c中定义⼀个值：int data；那么在两个点c⽂件中都加上：extern int data，那么，恭喜你，这个变量能被这三个.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 语言允许我们在一个源文件中直接使用另一个源文件中定义的变量，但这种做法可能导致维护困难和不一致的链接。
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变量。
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）变量尤其是对于变量来说。
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(); // 调用外部函数// 其他操作}。
extern用法多文件 c语言
标题：extern用法在C语言多文件开发中的应用摘要：extern关键字在C语言中被广泛应用于多文件开发中，在本文中将探讨extern的定义、作用以及在多文件开发中的具体应用。
一、extern关键字的定义extern是C语言中的一个关键字，其作用是告诉编译器某个变量或者函数是在别的文件中定义的。
当一个变量被声明为extern时，意味着该变量并没有在当前文件中定义，而是在其他文件中定义的。
二、extern关键字的作用1. 允许在一个文件中访问其他文件中定义的变量在多文件开发中，有时候需要在一个文件中访问其他文件中定义的全局变量。
这时可以使用extern关键字来声明该变量，以便在当前文件中使用。
2. 解决多文件共享全局变量的重定义问题如果在多个文件中定义了同名的全局变量，编译器会报错说重定义了全局变量。
这时可以使用extern关键字来解决该问题，只需要在定义变量的文件中使用extern声明该变量，而在其他文件中使用正常的全局变量定义即可。
3. 允许在不同文件中访问其他文件中定义的函数除了能够访问其他文件中定义的变量外，extern关键字也可以用于声明函数。
这样就可以在一个文件中调用其他文件中定义的函数。
三、extern关键字在多文件开发中的具体应用在实际的多文件开发中，extern关键字有着广泛的应用。
下面举几个具体的例子来说明extern在多文件开发中的应用。
1. 全局变量的共享在一个项目中，可能会有多个文件需要共享同一个全局变量。
假设有一个全局变量在文件A中定义，在文件B中需要访问该变量，这时就可以在文件B中使用extern关键字来声明该变量，以便在文件B中使用该全局变量。
2. 函数的调用在一个项目中，可能会有多个文件需要调用同一个函数。
假设有一个函数在文件A中定义，在文件B中需要调用该函数，这时就可以在文件B中使用extern关键字来声明该函数，以便在文件B中调用该函数。
3. 解决重定义问题在一个项目中，可能会有多个文件定义了同名的全局变量。
C语言全局变量多文件使用
C语⾔全局变量多⽂件使⽤
定义⼀个全局变量，想在多个⽂件中使⽤，代码如下：
//var.h
extern int var ;
//var.c
#include"var.h"
int var = 10;
//otherA.c
#include"var.h"
//otherB.c
#include"var.h"
//otherC.c
#include"var.h"
只能在⼀个⽂件⾥⾯赋初值，否则链接出错。
看到个C的题：
全局变量可不可以定义在可被多个.C⽂件包含的头⽂件中？为什么？
上⾯那种是不可以的，但是在前⾯加上static就可以了。
加上static就是静态全局变量了，只在本模块中使⽤。
全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。
全局变量本⾝就是静态存储⽅式，静态全局变量当然也是静态存储⽅式。
这两者在存储⽅式上并⽆不同。
这两者的区别虽在于⾮静态全局变量的作⽤域是整个源程序，当⼀个源程序由多个源⽂件组成时，⾮静态的全局变量在各个源⽂件中都是有效的。
⽽静态全局变量则限制了其作⽤域，即只在定义该变量的源⽂件内有效，在同⼀源程序的其它源⽂件中不能使⽤它。
由于静态全局变量的作⽤域局限于⼀个源⽂件内，只能为该源⽂件内的函数公⽤，因此可以避免在其它源⽂件中引起错误。
把局部变量改变为静态变量后是改变了它的存储⽅式即改变了它的⽣存期。
把全局变量改变为静态变量后是改变了它的作⽤域，限制了它的使⽤范围。
c语言结构体定义和使用 extern
c语言结构体定义和使用extern 在C语言中，结构体（struct）是一种用户自定义的数据类型，它可以包含多个不同类型的数据项。
extern关键字则用于声明一个变量或函数在别的文件中定义。
以下是一个结构体定义和使用extern的示例：假设我们有两个C文件：main.c和data.c。
data.c// 定义一个结构体typedef struct {int id;char name[50];} Person;// 在此文件中声明一个全局变量extern Person p;main.c#include <stdio.h>// 声明一个Person结构体类型的全局变量extern Person p;int main() {// 在main函数中访问pprintf("Person ID: %d\n", p.id);printf("Person Name: %s\n", );return 0;}在这个例子中，我们首先在data.c文件中定义了一个名为Person的结构体，并声明了一个全局的Person类型的变量p。
然后，在main.c文件中，我们声明了与data.c中相同的全局变量p，并使用它来访问结构体的数据。
这样，即使变量p是在另一个文件中定义的，我们仍然可以在main.c中访问它。
这就是使用extern的关键点。
注意：在这个例子中，我们必须保证data.c被编译和链接到最后的程序中，因为全局变量p是在那里定义的。
如果只编译和链接main.c，那么在试图访问p 时将会出现未定义的行为。
c语言中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在函数内部的作用域
外部变量 (extern) 在函数内部的作用域在计算机编程中，外部变量 (extern) 是一种用于在一个源文件中使用另一个源文件中定义的全局变量的方式。
在函数内部使用 extern 声明的外部变量，可以让函数访问其他源文件中的全局变量。
在本文中，我将深入探讨 extern 在函数内部的作用域，以及如何使用它来提高代码的模块化和复用性。
1. extern 的基本概念extern 关键字用于声明一个变量或函数是在别处定义的。
它告诉编译器，某个变量或函数不是在本文件中定义的，而是在另外的源文件中定义的。
在函数内部使用 extern 声明的外部变量时，编译器会在信息阶段将其与实际的全局变量进行关联。
2. 使用 extern 在函数内部访问全局变量假设有两个源文件 file1.c 和 file2.c，file1.c 中定义了一个全局变量count，我们希望在 file2.c 中的某个函数中使用它。
此时我们可以在file2.c 中使用 extern 声明来引用 file1.c 中定义的 count 变量。
具体做法是在 file2.c 中使用 extern 声明 count，然后就可以在函数中使用 count 了。
3. extern 的作用域在函数内部使用 extern 声明的变量，其作用域与普通全局变量并无不同，仍然具有整个文件作用域。
也就是说，extern 声明的外部变量可以在文件中的任何地方使用，包括在函数内部和函数外部。
4. 优点和注意事项使用 extern 可以帮助我们分离代码，将变量的定义和使用进行分离，提高代码的模块化和复用性。
需要注意的是，虽然使用外部变量可以方便地在不同文件之间共享数据，但过度使用外部变量也会导致代码的可读性和维护性降低。
在使用 extern 的时候，需要权衡好代码的模块化和复用性。
总结在本文中，我们深入探讨了 extern 在函数内部的作用域。
通过extern 声明外部变量，我们可以在一个源文件中访问另一个源文件中定义的全局变量，实现了代码的模块化和复用性。
extern使用方法
extern使用方法今天咱们来唠唠这个有点神秘又很实用的“extern”。
“extern”呢，在C或者C++语言里可算是个小明星哦。
简单来说，它主要是用来声明变量或者函数是在其他文件中定义的。
就好像你要找一个住在隔壁村（其他文件）的小伙伴，你得先跟大家说“我有个小伙伴在隔壁村呢”，这就是“extern”的声明作用。
比如说，你有两个源文件，一个叫main.c，一个叫func.c。
在func.c里面你定义了一个超酷的函数，像这样：c.int superFunction() {return 42;}那在main.c里面如果你想要用这个函数，你就得先“extern”一下这个函数啦。
就像这样：c.extern int superFunction();int main() {int result = superFunction();return 0;}这就相当于告诉main.c，“有个叫superFunction的函数在别的地儿呢，你可别找不到它哦。
”再说说变量哈。
如果在一个文件里定义了一个全局变量，在另一个文件想用，也得靠“extern”。
假设在一个文件里有这么个全局变量：c.int globalVar = 10;在另一个文件里要是想用这个变量，就可以这样：c.extern int globalVar;int main() {globalVar = 20;return 0;}不过宝子们要注意哦，“extern”只是声明，不是定义。
你不能在声明的时候给它初始化哦，像这样是不对滴：c.extern int wrongVar = 5;这就好比你不能一边说“我的小伙伴在隔壁村呢”，一边又说“这个小伙伴其实就在我这儿，而且他叫这个名字”，是不是很混乱呀？“extern”就像是一个桥梁，把不同文件之间的变量和函数连接起来，让它们可以愉快地互动。
掌握了“extern”，就像是掌握了一种让代码各个部分友好交流的魔法呢，宝子们是不是觉得很有趣呀？。
c语言 extern用法
c语言extern用法什么是extern关键字？在C语言中，`extern`是一个关键字，用于说明一个变量或函数在其他文件中定义。
在别的文件中用`extern`来声明这个变量或函数，从而让编译器知道它是在其他文件中定义的。
`extern`关键字有几种用法？1. 外部变量定义当我们需要声明一个外部定义的变量时，使用`extern`关键字。
外部定义的变量是指在全局范围内声明的变量，其作用域比较大，可以在不同的文件中使用。
在一个源文件中，我们可以用如下的方式定义一个外部变量：int external_var = 0;如果在其他文件中需要使用这个变量，可以用`extern`关键字声明该变量:extern int external_var;这个声明告诉编译器，这个变量已经在另一个文件中定义。
在C语言中，除了函数参数以外的变量默认都是外部变量。
2. 外部函数定义`extern`关键字也可以用于声明外部定义的函数。
在不同的文件中，我们可以使用如下代码定义和声明一个函数：在一个文件中定义函数int sum(int a, int b) {return a + b;}在另一个文件中声明函数extern int sum(int a, int b);这里的函数`sum()`在一个文件中被定义，而在其他文件中被声明。
因为C语言中不允许在一个源文件中定义多个同名函数，因此需要使用`extern`声明重复的函数。
3. 引用已定义的外部变量如果我们希望在一个文件中使用另一个文件中定义的外部变量，那么就需要使用`extern`关键字。
以下是一个示例程序：example1.c：#include <stdio.h>int external_var = 5;int main() {extern int external_var; 声明在其他文件中定义的external_var变量printf("The value of external_var is: %d\n", external_var);return 0;}example2.c：extern int external_var; 在文件中声明external_var变量int main() {external_var = 10; 修改在其他文件中定义的external_var变量的值return 0;}在`example1.c`文件中，我们定义了一个全局变量`external_var`。
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语言中用于声明一个变量或函数是在其他地方定义的关键字。
C语言中extern的用法(带有例子)
C语言中extern的用法在C语言中，修饰符extern用在变量或者函数的声明前，用来说明“此变量/函数是在别处定义的，要在此处引用”。
1. extern修饰变量的声明。
举例来说，如果文件a.c需要引用b.c中变量int v，就可以在a.c中声明extern int v，然后就可以引用变量v。
能够被其他模块以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原则的一种体现吧！这样做的一个明显的好处是，会加速程序的编译（确切的说是预处理）的过程，节省时间。
在大型C程序编译过程中，这种差异是非常明显的。
3. 此外，extern修饰符可用于指示C或者C＋＋函数的调用规范。
比如在C＋＋中调用C库函数，就需要在C＋＋程序中用extern “C”声明要引用的函数。
C语言中extern的用法
C语⾔中extern的⽤法 extern⽤在变量或函数的声明前，⽤来说明“此变量/函数是在别处定义的，要在此处引⽤”。
extern修饰变量的声明。
举例：若a.c中需引⽤b.c中的变量int v，可以在a.c中声明extern int v，然后就可以引⽤变量v;需要注意的是，被引⽤的变量v的链接属性必须是外链接(external)的，也就是说a.c要引⽤到变量v，不只是取决于在a.c中声明extern int v，还取决于变量v本⾝是能够被引⽤到。
这⾥涉及到另外⼀个话题---变量的作⽤域。
能够被其他模块以extern引⽤到的变量通常是全局变量。
extern int v可以放在a.c中的任何地⽅，⽐如可以在a.c中函数func()定义的开头处声明extern int v，然后就可以引⽤到变量v了，只不过这样只能在func()作⽤域中引⽤变量v。
另外⼀点要说明的是在b.c中需要对int v 做什么处理吗？那就是不能定义成静态变量static int v,否则不能使⽤。
fileb.cstatic int A;int main(){...}filea.cextern A;{ A = A*n; //出错}另外有⼈会有疑问为什么不在b.v⽂件中声明extern A；这样可以表⽰出A的特殊性，仔细想想真的不需要。
extern修饰函数的声明。
本质上讲，变量和函数没有区别。
函数名是指向函数⼆进制块开头处的指针。
如果⽂件a.c要引⽤b.c中的函数，⽐如在b.c中原型是int func(int m)，那么就可以在a.c中声明extern int func(int m)，然后就能使⽤func()来做任何事情。
就像变量的声明⼀样，extern int func(int m)可以放在a.c中的任何位置，⽽不⼀定⾮要放在a.c的⽂件作⽤域的范围中， 对其他模块中函数的引⽤，最常⽤的⽅法是包含这些函数声明的头⽂件。
使⽤extern和包含头⽂件来引⽤函数的区别：extern的引⽤⽅式⽐包含头⽂件要间接得多。