extern

意思是这个链接非本站链接，不要爬取也不要传递权重，其实目的是为了更好的seo优化，希望对你有帮助

extern 修饰符用于声明在外部实现的方法。 extern 修饰符的常见用法是在使用 Interop 服务调入非托管代码时与 DllImport 特性一起使用。 在这种情况下，还必须将方法声明为 static参考： http://msdn.microsoft.com/zh-cn/vstudio/e59b22c5 abstract用于修饰抽象类，代表抽象的意思partial是局部类型的意思参考： http://zhidao.baidu.com/question/94537770.html

是指外部收益，与正外部效应相随应，比如有人家种了一个花园，那么对于邻居或路人来说会带来美的欣赏与香的享受，即对于邻居或路人具有外部收益。

auto是自动变量，这类变量被存放在动态存储区中。register是寄存器变量，，他可以提高数据的存取速度，可以快速的存储以提高处理效率。extern是外部变量，他的作用范围是从定义开始到文件结束。

这里涉及两个知识点。第一个是ingress ，第二个是external domains。ingress 大家可能比较熟悉，比如下面的配置，访问hello-world.info的域名，请求”/“目录，将会把请求转发到web 这个服务。 external domains大家可能不经常使用，这个是k8s 提供的CNAME能力，比如下面通过外部域名的功能，为my-service 的域名增加一个 my.database.example.com的CNAME，这样当我们在容器里面访问 my-service域名的时候，域名解析到CNAME my.database.example.com，从而将请求转发到 my.database.example.com 。 但外部域名有个小问题，就是它只是重定向域名，并不会修改 HTTP header，这就导致一个问题：请求url 里面域名和header中的域名不一致。而ingress 大部分都是HTTP 请求。比如下面service 的定义。 当通过 my-sample.com 请求ingress的时候，ingress转发请求的时候， HTTP HOST header 还是my-sample.com，但上面设置的外部域名是 example.com，这就导致不一致了，nginx无法转发流量。 但我们还可以通过 nginx.ingress.kubernetes.io/upstream-vhost 这个annotation修改我们的请求header，如上面例子，我们将请求header的HOST 修改成 example.com 就可以成功请求了。

说道抽象类abstract，就不得不说一下external关键字，external关键字估计用到人很少，在看源码的时侯经常可以看到，如下： external只声明方法，声明的方法需要由外部去实现 ，通常是由底层sdk根据不同平台(vm、web等)实现；若外部没实现，则会返回null； external声明的方法，通过@patch注解实现 ， 结构如上 ； 比如Object里各种external声明方法的 实现如下 ： 移动端external声明方法实现在vm目录下： web端external声明方法实现在js_runtime目录下： external方法的实现文件一般命名为xxx_patch.dart，如在vm/lib目录下，可以看到各种xxx_patch.dart文件： 可以在终端通过grep搜索命令找到对应类里external方法实现的xxx_patch.dart文件： 以查找Object类里external方法的实现为例： 1、Object类定义如下： 可以看到Object类里有很多方法都是用external声明 2、在flutter sdk目录/bin/cache/dart-sdk/lib/_internal目录下，执行查找class Object命令： 由此可知：web端Object实现文件是./js_runtime/lib/core_patch.dart 移动端Object实现文件是./vm/lib/object_patch.dart 打开web端Object实现文件./js_runtime/lib/core_patch.dart，如下： 打开移动端Object实现文件./vm/lib/object_patch.dart，如下： 可以看到Object里各种external声明方法对应的@patch注解实现方法

你这个需要加上 #include “存放Cchengxu方法的文件名”，不然的话main方法只在他自己那个.c文件里找这个方法，这样是找不到的。再者，你最好不要用中文做文件名。即便是pinyin也不要用中文，因为有些时候，路径是不支持中文的。

clrscr是TC特有的，其它的C语言环境没有这个函数，也就没有头文件包含这个函数。建议使用system("cls");来取代clrscr();比较通用，兼容性好一点。system()函数在#include<stdlib.h>里面

把 clrscr(); 改写为system("CLS");

external parts 指的就是阀门的阀体和阀盖

你的主函数明显括号不对应嘛，我检查了一下，你主函数上面差一个}，主函数中又多了一个};不过这样修改了还有一个错误，你定义的模板P在使用时候没指定。因为你看你的InPutTSMatrix()函数参数是模板类型，MultSMatrix()函数里面根本没有模板类型P。看你这里根本没必要用模板嘛，所以我又改了一下，把模板去掉了。结果发现又有一个错误，Count(M);Count(N);这两个什么错误，你根本没有写这两个函数嘛，剩下的就得靠你自己了，我不可能帮你再添加一个函数吧，嘿嘿。。。。另外OutPutSMatrix(Q);这个函数也没有，你程序没写完整吧，下面的程序是我改了的结果，不过上面两个函数没定义，你得接着写完。。。。#include<iostream.h>#include<iomanip.h>constintMAXSIZE=100;//定义非零元素的对多个数constintMAXROW=10;//定义数组的行数的最大值typedefstruct{//定义三元组的元素inti,j;inte;}Triple;typedefstruct{//定义普通三元组对象Tripledata[MAXSIZE+1];intmu,nu,tu;//矩阵的行数列数非零元个数}TSMatrix;typedefstruct{//定义带链接信息的三元组对象Tripledata[MAXSIZE+2];intrpos[MAXROW+1];intmu,nu,tu;}RLSMatrix;//template<classP>boolInPutTSMatrix(RLSMatrix&T,inty){//输入矩阵，按三元组格式输入cout<<"输入矩阵的行，列和非零元素个数:"<<endl;cin>>T.mu>>T.nu>>T.tu;cout<<"请输出非零元素的位置和值:"<<endl;intk=1;for(;k<=T.tu;k++)cin>>T.data[k].i>>T.data[k].j>>T.data[k].e;returntrue;}//两个矩阵相乘//template<classP>boolMultSMatrix(){RLSMatrixM,N,Q;//构建三个带“链接信息”的三元组表示的数组InPutTSMatrix(M,1);//用普通三元组形式输入数组InPutTSMatrix(N,1);Count(M);Count(N);/////////这里的函数没定义啊。。。。。。。。。。。if(M.nu!=N.mu)returnfalse;Q.mu=M.mu;Q.nu=N.nu;Q.tu=0;//Q初始化intctemp[MAXROW+1];//辅助数组intarow,tp,p,brow,t,q,ccol;if(M.tu*N.tu){//Q是非零矩阵for(arow=1;arow<=M.mu;arow++){///memset(ctemp,0,N.nu);for(intx=1;x<=N.nu;x++)//当前行各元素累加器清零ctemp[x]=0;Q.rpos[arow]=Q.tu+1;//当前行的首个非零元素在三元组中的位置为此行前所有非零元素+1if(arow<M.mu)tp=M.rpos[arow+1];elsetp=M.tu+1;for(p=M.rpos[arow];p<tp;p++){//对当前行每个非零元素进行操作brow=M.data[p].j;//在N中找到i值也操作元素的j值相等的行if(brow<N.mu)t=N.rpos[brow+1];elset=N.tu+1;for(q=N.rpos[brow];q<t;q++){//对找出的行当每个非零元素进行操作ccol=N.data[q].j;ctemp[ccol]+=M.data[p].e*N.data[q].e;//将乘得到对应值放在相应的元素累加器里面}}for(ccol=1;ccol<=Q.nu;ccol++)//对已经求出的累加器中的值压缩到Q中if(ctemp[ccol]){if(++Q.tu>MAXSIZE)returnfalse;Q.data[Q.tu].e=ctemp[ccol];Q.data[Q.tu].i=arow;Q.data[Q.tu].j=ccol;}}OutPutSMatrix(Q);/////////这里的函数没定义啊。。。。。。。。。。。returntrue;}}intmain(){MultSMatrix();//调用矩阵相乘函数return0;}

a = 5b = 25`````上面是函数里面的输出····下面是主函数的输出·····a = 5b = 15因为楼主你在函数体里面都有另外定义x y，所以你在函数体外面定义的自动被屏蔽了...

没有头文件test.h。对于共有的头文件test.h，有extern这是对全局变量的声明，要在a.c文件中使用变量num。必须要包含头文件test.h，因此extern全局变量在没有头文件test.h的情况会失败。全局改量是指在函数内部定义的变量称为局部变量，它的作用域是从定义处直到文件结束。

声明它是全局函数，使得其他文件的函数可以调用这个函数。

比如你在文件X中定义 char A；在文件Y中使用 extern short A；那么在文件Y中这个A变量就是一个short类型的变量，是两个字节，取值范围也是short类型的范围，但是如果你对这个A变量进行修改，那么在X文件中的A会做一个强制转换，把Y中的赋值转换成char型。所以如果你对A的赋值超过了char的表示范围，那么该变量在X和Y中的值是不同的！例如你在Y中执行 A = 258；那么在Y文件中A的值就是作为258来使用；但是在X中你会发现A的值为2

static:一、在C中，static主要定义全局静态变量、定义局部静态变量、定义静态函数。1、定义全局静态变量：在全局变量前面加上关键字static，该全局变量变成了全局静态变量。全局静态变量有以下特点。a.在全局数据区分配内存。b.如果没有初始化，其默认值为0.c.该变量在本文件内从定义开始到文件结束可见,且在外部文件不可见. 2、定义局部静态变量：在局部变量前面加上关键字static，其特点如下：a.该变量在全局数据区分配内存。b.它始终驻留在全局数据区，直到程序运行结束。c. 其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束。 3、定义静态函数：在函数返回类型前加上static关键字，函数即被定义为静态函数，其特点如下：a.静态函数只能在本源文件中使用b.在文件作用域中声明的inline函数默认为static类型二、在C++中新增了两种作用：定义静态数据成员或静态函数成员。静态数据成员:a.内存分配：静态数据成员在程序的全局数据区去分配。b.初始化和定义： 静态数据成员必须在类定义外初始化，但const静态数据成员除外，const静态数据成员可以在类体中初始化(也可以像非const一样在类外初始化)。例如: class c1{public:private:static int num;static const string name = "chio";};int c1::num = 20;//没有const修饰的静态成员数据,必须类外定义并且初始化静态函数成员:类成员函数(无论是static成员函数或非static成员函数)都可以直接访问static数据成员，但是static成员函数只能访问static数据成员。并且可以通过类名直接调用. extern:extern可以置于变量或函数前，以在别的文件中标识变量或函数的定义，并提示编译器遇到此变量或函数时在其他模块中寻找其定义.extern在局部函数中声明时,表示此变量,在局部函数外(包括函数外,和文件外).extern声明的变量(即文件公用的变量)最好放在头文件中对于extern变量来说，仅仅是一个变量的声明，其并不是定义，不会分配内存空间。 extern表示将变量或函数声明为外部链接，变量默认是内部链接，函数默认是外部链接。因此用来外部链接的函数，声明时有无extern都可以连接通过。而全局变量则不行。通常，在模块的头文件中，对本模块提供给其他模块引用的函数和全局变量以关键字extern声明。

关注这个问题

首先纠正你的一个错误，extern是用来声明变量而不是定义变量的x0dx0ax0dx0a当你需要在一个c语言文件中使用另外一个c语言文件中定义的变量时就需要加上extern来声明，这样编译器就知道这个变量是在别的文件中定义的。x0dx0a比如：你在foo.c中定义了一个全局变量int a=10,你在fff.c中想使用这个变量a，那么你就需要在使用之前在fff.c中用extern声明这个变量。extern int a；

这是一个比较普通的知识点,但是还是做个笔记记起来; 1.在发送通知的控制器的.h文件中声明XXVCLoginSuccessNotification 登录成功的通知名称 2.在发送通知的控制器的.m文件中定义其值 3.在另一个页面注册通知的.m文件中直接调用(这里有个条件，就是导入了XXLovinVC头文件的条件) 4.如果在一个没有导入声明XXVCLoginSuccessNotification的文件中使用，则会报错，如下图。 5.如何解决？需要在此文件的.h或者.m文件中，再次声明文章抄自: 落夏简叶的_iOS中extern的用法 .

extern是关键字，修饰函数或者变量，来表明函数或变量的定义在别的文件中链接器遇到此函数或变量时在其他模块中解析或绑定；

一般来说是你定义了一个全局变量，在定义这个全局变量的文件外的其他文件中如果需要使用这个全局变量你就要用extern 加上你刚才定义的语句外部声明下

如果使用了extern，a就退化成了普通的指针，不是数组了，所以使用sizeof就不好使了。有两种方案：1、将指针的大小使用宏定义，或者全局变量进行记录，并在file2中进行extern。2、在file1中写一个函数，用来求数组a的大小，在file2中调用该函数。

extern int i；//写成i = 10；行吗？-- 在函数体内赋值是可以的。extern void fun（void）；//两个void 可否省略？-- 不可省略。两个void是用来说明外部函数的返回值和参数的。extern double j；//这样行吗？为什么？-- 不可以。C程序中，不允许出现类型不同的同名变量。j = 3.0；//这样行吗？为什么？-- 可以。但是数值会被取整。 C中，extern的作用是声明一个位于其他程序文件内的全局变量，以便在本程序文件中正确使用该变量。就是说，变量已经在别的文件里声明过了，那么在其他的文件里只要在同样的变量声明语句前用extern加以修饰，就可以在程序里如同一个普通变量一样使用了。

input ，定义的参数程序执行过程中不能更改。extern ，定义的参数程序执行过程中能更改。

extern 修饰符用于声明在外部实现的方法。extern 修饰符的常见用法是在使用 Interop 服务调入非托管代码时与 DllImport 属性一起使用。在这种情况下，还必须将方法声明为 static DllImport("avifil32.dll")] private static extern void AVIFileInit();也就是说这个方法是放在申明的类之外的类中实现 的.

我刚才做了一个实验：//a.cpp #include <string>std::string i;//b.cpp#include <iostream>#include <string>extern std::string i;int main (){std::cout << i << std::endl;}运行结果为:（上面是一空行:由于末尾用了endl)如果没有a.cpp这个文件，运行出错这是一对实验（有没有a.cpp文件）可得出这样的结论：a.cpp中std::string i;是定义（本来就是）b.cpp中extern std::string i; 则是声明（你的问题）先别急，这只是实验结果。我们还需要理论依据，那么下面就试着解释一下：下面是另一个例子（也是第二个实验）你应该知道内置类型（int等）如果作为全局变量时，定义的同时也就初始化了（一个内置类型有其对应的默认值；如果你将自定义类型也看成内置类型，那么就等于说，一个自定义类型有其对应的默认值（由默认构造函数完成））。如//c.cppint i;//d.cpp#include <iostream>extern int i;int main (){std::cout << i << std::endl;}那么在这里int i; 就是定义（并且初始化了i，初始值为0）因而输出结果为0//这个实验的运行结果符合理论依据。（我使用的编译器是visual studio 2008）从这两个实验来看：（将两个“默认”等同起来）int i;std::string i;都可以作为初始化i的定义性语句。那么extern int i;extern std::string i; 也具有定义行为（这个很明显与extern的用法相悖）在以上两个试验中：int 与 string 有“区别”吗？所有的代码都一样只不过把std::string 换成了 int而已！如果你能解释int的情况，那么我想std::string问题也就迎刃而解了！于是我个人总结出一个结论： 不论是内置类型还是自定义类型，前面有extern关键字，如果没有显式地初始化参数（即就是自定义类型的默认构造函数被extern屏蔽了，不起初始化的作用），那么就按声明对待。

简单理解，头文件就是在源文件头部用来被包含的文件。这里的包含是#include预处理命令，包含的过程就是把头文件的文本完整地复制到源文件中的对应位置，然后删除此行#include预处理命令。由于文件包含是预处理器在翻译过程之前完成的，因此和整个编译过程没有必然联系，一个源文件在与处理过程中可以进行任意次文件包含。对于重复的代码（例如函数声明和宏定义），可以写在头文件中给多个源文件包含。当然包含之后会不会对编译造成影响，要看头文件和源文件的内容。习惯上，一个源文件对应了一个头文件，其中头文件中为extern函数和对象声明和宏定义，源文件里为对应的全局/static对象定义和extern/static函数的实现。但是并非一定要按照这个习惯。头文件的存在是为了被源文件包含，如果只被一个源文件包含，那么相当于把这个头文件放进源文件中代替#include行，此时头文件不是必需的。头文件也可以不对应源文件，当这个头文件声明的函数和对象都定义在库文件中时——比较常见的例子就是标准库的头文件。

extern extern 用来引用别处定义的变量和函数。 例如： 1.c文件如下 现有一个2.c 文件想引用1.c 中的 a 和 b 变量和函数，就可以使用 extern 2.c 编译1.c和2.c成功执行。 include 若2.c 引用了很多其他文件的变量或者函数，则可以讲这些声明统一放入一个头文件中，例如： 2.h 文件： 这样2.c 直接引用头文件即可 2.c:

兄弟，你是想试试几个文件连在一起如何用吧，呵呵！你试着把三个文件中的这个extern delta,a,b,c;改成extern float delta;extern int a,b,c;就是连它的类型也要声明哦！

所谓extern就是说明这个变量在别的文件中声明过了，在此引用。所以找到你这几个变量声明的地方，拷贝过来，每个前面加个extern即可。

extern只是外部引用，不能用来定义。假如用extern定义的话，编译不会报错，链接时会出错，extern可以置于变量或者函数前，以标示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。

如果使用extern关键字，代表声明一个变量或函数，该变量/函数的定义由编译器到其他文件中寻找。如果使用了extern关键字后又在下面定义了变量/函数，那么则会覆盖其他文件中的定义，此时extern关键字无效。

extern 是定义外部变量的意思，例如一个工程里面有多个.C文件，在main.c里面可以调用同一个工程里面多个.C文件里面的函数，列如：main.C文件里面要调用：Delay.C文件里面的 Delay_1ms（）延时子函数，前面必须加extern Delay_1ms（）；extern 就是定义外部变量或者函数的，希望我的回答对你有帮助！

linux是由C写的所以在C中，extern表示全局，即该函数在很大范围都使用具体查C的资料或教程

extern是声明外部变量，正如它的英文名字一样，你可以在其他文件当中使用它

如果函数的声明中带有关键字extern，仅仅是暗示这个函数可能在别的源文件里定义，没有其它作用。即下述两个函数声明没有明显的区别：　　externintf();和intf();　　当然，这样的用处还是有的，就是在程序中取代include“*.h”来声明函数，在一些复杂的项目中，比较习惯在所有的函数声明前添加extern修饰。

extern C的惯用法（1）在C++中引用C语言中的函数和变量，在包含C语言头文件（假设为cExample.h）时，需进行下列处理：extern C{#include cExample.h}而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern C声明，在.c文件中包含了extern C时会出现编译语法错误。笔者编写的C++引用C函数例子工程中包含的三个文件的源代码如下：/* c语言头文件：cExample.h */#ifndef C_EXAMPLE_H#define C_EXAMPLE_Hextern int add(int x,int y);#endif/* c语言实现文件：cExample.c */#include cExample.hint add( int x, int y ){return x + y;}// c++实现文件，调用add：cppFile.cppextern C{#include cExample.c}int main(int argc, char* argv[]){add(2,3);return 0;}如果C++调用一个C语言编写的.DLL时，当包括.DLL的头文件或声明接口函数时，应加extern C {　}。（2）在C中引用C++语言中的函数和变量时，C++的头文件需添加extern C，但是在C语言中不能直接引用声明了extern C的该头文件，应该仅将C文件中将C++中定义的extern C函数声明为extern类型。笔者编写的C引用C++函数例子工程中包含的三个文件的源代码如下：//C++头文件 cppExample.h#ifndef CPP_EXAMPLE_H#define CPP_EXAMPLE_Hextern C int add( int x, int y );#endif//C++实现文件 cppExample.cpp#include cppExample.hint add( int x, int y ){return x + y;}// C实现文件 cFile.c/* 这样会编译出错：#include cppExample.h */extern int add( int x, int y );int main( int argc, char* argv[] ){add( 2, 3 );return 0;}总结 　C和C++对函数的处理方式是不同的.extern C是使C++能够调用C写的库文件的一个手段，如果要对编译器提示使用C的方式来处理函数的话，那么就要使用extern C来说明。探索C++的秘密之详解extern C　时常在cpp的代码之中看到这样的代码: #ifdef __cplusplus extern C { #endif //一段代码 #ifdef __cplusplus } #endif 这样的代码到底是什么意思呢？首先，__cplusplus是cpp中的自定义宏，那么定义了这个宏的话表示这是一段cpp的代码，也就是说，上面的代码的含义是:如果这是一段cpp的代码，那么加入extern C{和}处理其中的代码。 要明白为何使用extern C，还得从cpp中对函数的重载处理开始说起。在c++中，为了支持重载机制，在编译生成的汇编码中，要对函数的名字进行一些处理，加入比如函数的返回类型等等.而在C中，只是简单的函数名字而已，不会加入其他的信息.也就是说:C++和C对产生的函数名字的处理是不一样的. 比如下面的一段简单的函数，我们看看加入和不加入extern C产生的汇编代码都有哪些变化: int f(void) { return 1; } 在加入extern C的时候产生的汇编代码是: .file test.cxx .text .align 2 .globl _f .def _f; .scl 2; .type 32; .endef _f: pushl %ebp movl %esp， %ebp movl $1， %eax popl %ebp ret 但是不加入了extern C之后 .file test.cxx .text .align 2 .globl __Z1fv .def __Z1fv; .scl 2; .type 32; .endef __Z1fv: pushl %ebp movl %esp， %ebp movl $1， %eax popl %ebp ret 两段汇编代码同样都是使用gcc -S命令产生的，所有的地方都是一样的，唯独是产生的函数名，一个是_f，一个是__Z1fv。 明白了加入与不加入extern C之后对函数名称产生的影响，我们继续我们的讨论:为什么需要使用extern C呢？C++之父在设计C++之时，考虑到当时已经存在了大量的C代码，为了支持原来的C代码和已经写好C库，需要在C++中尽可能的支持C，而extern C就是其中的一个策略。 试想这样的情况:一个库文件已经用C写好了而且运行得很良好，这个时候我们需要使用这个库文件，但是我们需要使用C++来写这个新的代码。如果这个代码使用的是C++的方式链接这个C库文件的话，那么就会出现链接错误.我们来看一段代码:首先，我们使用C的处理方式来写一个函数，也就是说假设这个函数当时是用C写成的: //f1.c extern C { void f1() { return; } } 编译命令是:gcc -c f1.c -o f1.o 产生了一个叫f1.o的库文件。再写一段代码调用这个f1函数: // test.cxx //这个extern表示f1函数在别的地方定义，这样可以通过 //编译，但是链接的时候还是需要 //链接上原来的库文件. extern void f1(); int main() { f1(); return 0; } 通过gcc -c test.cxx -o test.o 产生一个叫test.o的文件。然后，我们使用gcc test.o f1.o来链接两个文件，可是出错了，错误的提示是: test.o(.text + 0x1f):test.cxx: undefine reference to "f1()" 也就是说，在编译test.cxx的时候编译器是使用C++的方式来处理f1()函数的，但是实际上链接的库文件却是用C的方式来处理函数的，所以就会出现链接过不去的错误:因为链接器找不到函数。 因此，为了在C++代码中调用用C写成的库文件，就需要用extern C来告诉编译器:这是一个用C写成的库文件，请用C的方式来链接它们。 比如，现在我们有了一个C库文件，它的头文件是f.h，产生的lib文件是f.lib，那么我们如果要在C++中使用这个库文件，我们需要这样写: extern C { #include f.h } 回到上面的问题，如果要改正链接错误，我们需要这样子改写test.cxx: extern C { extern void f1(); } int main() { f1(); return 0; } 重新编译并且链接就可以过去了. 总结 C和C++对函数的处理方式是不同的.extern C是使C++能够调用C写作的库文件的一个手段，如果要对编译器提示使用C的方式来处理函数的话，那么就要使用extern C来说明。

extern 本意是"外部" 如果修饰一个变量或者函数 则表示它在其他的文件定义过了。如果是 extern "C" 则是用于在C++环境下编译C语言。因为C++ C函数在编译器内部表示不一样，这样声明后就以C语言函数内码表示为准

static标识的变量表示该变量只能在该区域内可见，ertern不能用来定义变量，只能用来告诉编译器，这个变量在别处定义，引用的外来变量。一般是全局变量

首先纠正你的一个错误，extern是用来声明变量而不是定义变量的当你需要在一个c语言文件中使用另外一个c语言文件中定义的变量时就需要加上extern来声明，这样编译器就知道这个变量是在别的文件中定义的。比如：你在foo.c中定义了一个全局变量int a=10,你在fff.c中想使用这个变量a，那么你就需要在使用之前在fff.c中用extern声明这个变量。extern int a；

其实说简单点就是你有两个以上的.C文件，如果把一个变量或者函数声明为extern，例：在文件a.c中声明extern a;那么这个变量a,就可以在文件b.c中使用，否则在b.c中无法使用这个变量。

我在VC下建了一个控制台程序。为了弄清楚，我建了2个文件。大致如下：//file.cvoid f1(void){printf("this is f1. ");}void f2(void){printf("this is f2. ");}//file2.cvoid f1(void);extern void f2(void);int main(void){f1();f2();}

extern可置于变量或者函数前，以表示变量或者函数的定义在别的文件中，提示编译器遇到此变量或函数时，在其它模块中寻找其定义。在你这个程序里，int i=1;相当于只在这个文件里的有效的全局变量，而extern int i;相当于一个使用范围更加广阔的全局变量。关系相当于局部变量和全局变量，在局部变量有效的范围内，指的变量都是局部变量。只有在局部变量无效时，才采用全局变量。明白么？

他们两个一个说的是外部函数 一个说的是全局函数 呵呵 两个都对 但在内核中 VegetaCT说的更合适一些

有几种情况：首先，extern和static完全不同，extern不能定义一个变量，extern表示的是“已经存在一个变量，但是不在当前的编译单元内，需要在其他编译单元中寻找。”static会定义一个变量，但是分成多种情况。---------------------------------------------------------------------先说extern 和 变量的关系。先说只有一个文件（编译单元）的：int i=10; //这个是定义一个全局变量，值为10extern int i=10; //这个是错误的，变量已经存在，怎么赋初值呢？extern int i; //这个和第一句 int i=10; 可以同时存在在一个文件中。再说跨文件（多个编译单元）的：文件一：（假设这个文件没有错误！！）int a=10;文件二：extern int a; // 这个正确extern float a; // 这个编译不会错，赋值会怎样呢？extern int b; //这个找不到int a=9; //这个出错，全局变量多次定义int a; //同上static int a=9; //这个正确，这个产生一个仅在文件二中有效的全局变量a，初值为9，注意在文件二中将看不到那个值为10的全局变量！！！！static就是刚才说的最后一种，此外就是函数内的使用了，不再多说了。特别的，这样是错误的：a.c:static int x=10;b.c:extern int x; //因为x只在a.c中，b.c中根本看不到x，所以这个extern还是找不到x，因此会在链接时报错。其他：extern尽量写到.h文件中，写到.c里就是错误的种子，以后它只能得到苦果！

extern 只是用来声明全局变量1.在一个文件中一般在开始处定义全局变量，定义方法可以如下两种（都一样）：#include....extern int a；//第一种int a；//第二种main（）.....也就是在一个文件中声明全局变量，extern可以省略2.如果在一个文件中定义了一个全局变量【（extern）int 】a，要想在另一个文件中使用这个变量，则要在另一个文件前面加上全局变量声明，即加上：extern int a；（extern 不可省略）这样两个文件的全局变量a就是同一个，它的值就可以互相使用了，也可以在任意文件中改变了

在全局范围：int i;这是定义，定义i，初始化为0。int i = 1;这是定义，定义i，初始化为1。extern int i = 1;这是定义，定义i，初始化为1。extern int i;这是声明，声明有一个变量i，它的定义可能在其它文件中。每个变量定义只能有一处。最好使每个变量都有且仅有一处定义。extern int i = 1;作用和int i = 1;没有区别，只是显式地提醒程序员i可能会在其它文件里用到。

在C++中external function是外部函数的意思，而外部函数有两种理解.(1)库函数是C语言的内部函数或自带函数,外部函数即程序员自定函数.(2)凡加写了extern 的函数是外部函数.

加了extern的函数，表示是外部函数，在多个文件的项目中，该函数可以被其他文件中的函数调用如果加了"C",则是告诉编译器此函数要按c的规则来编译， 例如：extern "C" void fun();

1.extern常用来声明在外部的非托管代码，例子：[DllImport("User32.dll")] public static extern int MessageBox(int h, string m, string c, int type);2.extern也可以用来引用外部别名，例如，可能必须在同一应用程序中使用程序集的两个或多个版本（它们里面的很多类都由相同的完全限定名）。通过使用外部程序集别名，可以将来自每个程序集的命名空间包装在由别名命名的根级别命名空间中，从而使这些命名空间可以在同一文件中使用。若要引用两个具有相同完全限定类型名的程序集，必须在命令提示符下指定别名，如下所示：/r:GridV1=grid.dll /r:GridV2=grid20.dll 这将创建外部别名 GridV1 和 GridV2。若要从程序中使用这些别名，请使用 extern 关键字引用它们。例如：extern alias GridV1; extern alias GridV2; class Test{ GridV1::N.A a; GridV1::N.B b1; GridV2::N.B b2; GridV2::N.C c;}该程序声明存在 extern 别名 GridV1 和 GridV2，但这些别名的实际定义在该程序的外部。同名的 N.B 类现在可分别通过 X.N.B 和 Y.N.B 引用，或者使用命名空间别名限定符通过 X::N.B 和 Y::N.B 引用。如果没有为程序声明的 extern 别名提供外部定义，则会发生错误。参考资料：msdn

它可以用作一种格式上的提示表明函数的定义可能在另一个源文件中, 但在 extern int f();和 int f();之间并没有实质的区别。

很积极阿

c 全局变量默认是extern　如果函数的声明中带有关键字extern，仅仅是暗示这个函数可能在别的源文件里定义，没有其它作用。即下述两个函数声明没有明显的区别：　　extern int f(); 和int f();　　当然，这样的用处还是有的，就是在程序中取代include “*.h”来声明函数，在一些复杂的项目中，比较习惯在所有的函数声明前添加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原则的一种体现吧！这样做的一个明显的好处是，会加速程序的编译（确切的说是预处理）的过程，节省时间。在大型C程序编译过程中，这种差异是非常明显的。3. 此外，extern修饰符可用于指示C或者C＋＋函数的调用规范。比如在C＋＋中调用C库函数，就需要在C＋＋程序中用extern “C”声明要引用的函数。这是给链接器用的，告诉链接器在链接的时候用C函数规范来链接。主要原因是C＋＋和C程序编译完成后在目标代码中命名规则不同

有几种情况：首先，extern和static完全不同，extern不能定义一个变量，extern表示的是“已经存在一个变量，但是不在当前的编译单元内，需要在其他编译单元中寻找。”static会定义一个变量，但是分成多种情况。---------------------------------------------------------------------先说extern和变量的关系。先说只有一个文件（编译单元）的：inti=10;//这个是定义一个全局变量，值为10externinti=10;//这个是错误的，变量已经存在，怎么赋初值呢？externinti;//这个和第一句inti=10;可以同时存在在一个文件中。再说跨文件（多个编译单元）的：文件一：（假设这个文件没有错误！！）inta=10;文件二：externinta;//这个正确externfloata;//这个编译不会错，赋值会怎样呢？externintb;//这个找不到inta=9;//这个出错，全局变量多次定义inta;//同上staticinta=9;//这个正确，这个产生一个仅在文件二中有效的全局变量a，初值为9，注意在文件二中将看不到那个值为10的全局变量！！！！static就是刚才说的最后一种，此外就是函数内的使用了，不再多说了。特别的，这样是错误的：a.c:staticintx=10;b.c:externintx;//因为x只在a.c中，b.c中根本看不到x，所以这个extern还是找不到x，因此会在链接时报错。其他：extern尽量写到.h文件中，写到.c里就是错误的种子，以后它只能得到苦果！

C函数前加extern表示该函数已经在其他文件中定义。 extern的定义： extern是C，C++中的一个关键字。extern可置于变量或者函数前，以表示变量或者函数的定义在别的文件中，提示编译器遇到此变量或函数时，在其它模块中寻找其定义。另外，extern也...

extern可置于变量或者函数前，以表示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。另外，extern也可用来进行链接指定。

extern关键字可以置于变量或者函数前，以标示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。这里起到的是声明作用范围的用处。extern的另外用法是当C和C++混合编程时假如c++调用的是c源文档定义的函数或变量，那么要加extern来告诉编译器用c方式命名函数：文档A.cpp调用a.c里面的变量i和函数callme()相关内容：C语言包含的各种控制语句仅有9种，关键字也只有32个，程序的编写要求不严格且以小写字母为主，对许多不必要的部分进行了精简。实际上，语句构成与硬件有关联的较少，且C语言本身不提供与硬件相关的输入输出、文件管理等功能，如需此类功能，需要通过配合编译系统所支持的各类库进行编程，故c语言拥有非常简洁的编译系统。

extern是全局变量声明只要声明全局变量就默认 前面加extern（程序员可以不加，但编译器默认加上）若本文件 引用别的文件中的全局变量 一定要加上extern 声明一下例如 #include "my_Fun.c" extern int b;//b是在my_Fun.c中声明了的一个全局变量 这个extern 是个声明他可以在任何地方声明 引用了一个全局变量 （可以试试 在main()函数执行完之后声明 也不会出错）这样在 工程的总头文件中就不需要考虑 先#include 哪个文件了

加上以后 外部函数可以调用该函数

extern是全局变量声明只要声明全局变量就默认 前面加extern（程序员可以不加，但编译器默认加上）若本文件 引用别的文件中的全局变量 一定要加上extern 声明一下例如 #include "my_Fun.c"extern int b;//b是在my_Fun.c中声明了的一个全局变量这个extern 是个声明他可以在任何地方声明 引用了一个全局变量 （可以试试 在main()函数执行完之后声明 也不会出错）这样在 工程的总头文件中就不需要考虑 先#include 哪个文件了

extern是外部声明用的，用来声明外部的函数或者变量定义。例如，你在1.C中定义了一个函数和变量：void fun1(void);int a = 0;而你要在2.c中调用 fun1()，并且读取a的值，那么需要再2.c的头部如下外部声明：extern void fun1(void);extern int a = 0;这样的话在编译器在编译2.c时，不会报错误，而在链接时找fun1、a，以实现对外部函数、变量的访问。

C函数前加extern表示该函数已经在其他文件中定义。extern的定义：extern是C，C++中的一个关键字。extern可置于变量或者函数前，以表示变量或者函数的定义在别的文件中，提示编译器遇到此变量或函数时，在其它模块中寻找其定义。另外，extern也可用来进行链接指定。

extern关键字可以置于变量或者函数前，以标示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。这里起到的是声明作用范围的用处。extern的另外用法是当C和C++混合编程时假如c++调用的是c源文档定义的函数或变量，那么要加extern来告诉编译器用c方式命名函数：文档A.cpp调用a.c里面的变量i和函数callme()扩展资料C语言包含的各种控制语句仅有9种，关键字也只有32个，程序的编写要求不严格且以小写字母为主，对许多不必要的部分进行了精简。实际上，语句构成与硬件有关联的较少，且C语言本身不提供与硬件相关的输入输出、文件管理等功能，如需此类功能，需要通过配合编译系统所支持的各类库进行编程，故c语言拥有非常简洁的编译系统。

extern关键字可以置于变量或者函数前，以标示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。这里起到的是声明作用范围的用处。extern的另外用法是当C和C++混合编程时假如c++调用的是c源文档定义的函数或变量，那么要加extern来告诉编译器用c方式命名函数：文档A.cpp调用a.c里面的变量i和函数callme()拓展资料1、可以通过把原函数名与参数信息结合，产生一个独特的内部名字，这种技术叫做名字修饰（Name Mangling）。名字修饰规则没有一个标准，所以不同的编译器的名字修饰规则也不一样。下面是一组函数，其中f()函数重载了：f(void)和f(int)是不同的函数，除了函数名相同以外没有任何关系。当生成obj目标文件时，为了区分它们，C++编译器根据参数信息进行了名字修饰：2、C语言中没有名字修饰（Name Mangling），因为C语言不支持函数重载。但是如果C++中含有C代码，在编译时C++编译器对C代码的函数也会进行名字修饰，函数名变了以后，将导致在C运行库中找不到对应函数，发生链接错误。为了防止C++编译器对C代码进行名字修饰，我们将C代码用extern “C”进行链接指定，告诉编译器，在生成中间文件时，不要对这部分代码进行名字修饰，而是生成符合C规则的中间符号名。添加了extern “C”链接指示后，上面的代码就能够正常运行了。

extern是全局变量声明，只要声明全局变量就默认 前面加extern(程序员可以不加，但编译器默认加上)若本文件 引用别的文件中的全局变量 一定要加上extern 声明一下。例如 #include "my_Fun.c" extern int b;//b是在my_Fun.c中声明了的一个全局变量 这个extern 是个声明他可以在任何地方声明 引用了一个全局变量 (可以试试 在main()函数执行完之后声明 也不会出错)这样在 工程的总头文件中就不需要考虑 先#include 哪个文件了

C函数前加extern表示该函数已经在其他文件中定义。extern的定义：extern是C，C++中的一个关键字。extern可置于变量或者函数前，以表示变量或者函数的定义在别的文件中，提示编译器遇到此变量或函数时，在其它模块中寻找其定义。另外，extern也可用来进行链接指定。

不算错误吧，你的main.c中把a.c文件包含进来了，也就实现了msg函数

extern 关键字 声明一个“外部变量” 。有了这个声明，就可以从声明开始的地方，合法地使用该外部变量了。 在例1中，我们在最后才定义了外部变量 g_X , g_Y ，由于外部变量定义的位置在main函数之后，因此本来我们在main函数中是不能够引用 g_X , g_Y 的，因为在使用的时候并没有定义它们的数值。现在我们在main函数中用 extern 对它们进行“外部变量声明”，就可以从声明的位置起使用它们了。 对于多个文件的工程，都可以采用例2的方法。 对于模块化的程序文件，可以先预留好外部变量的接口，也就是只采用 extern 声明变量，而不定义变量值，像例2中的 max.c 中那样。变量值的定义留给使用者。 通常，这些外部变量的接口都是在模块程序的 头文件 中声明的。当需要使用该模块时，只需在使用时具体定义一下外部变量即可。比如main.c中的 g_X , g_Y 。 不过需要注意，由于用 extern 引用外部变量，可以在引用的模块内修改变量的值，因此如果有多个文件同时对引用的变量进行操作，并且可能会修改该变量，那么就会影响其他模块的使用。因此需要慎重使用。 总结 一般来说，头文件只能声明函数和变量，其定义只能在某个.c文件中

好问题刚刚搜了一下extern是告诉编译器，当前的变量会在链接时的某个目标文件中出现函数默认是extern的，因此是冗余的最佳实践：假如有个模块叫x，在x.h里定义extern 变量，在x.c里定义变量的值英文好的话自己看网页链接

放在头文件里。用于被其他cpp文件调用

extern可省略不写。本文件里：在一个文件里，有不止一个函数，外部变量在第一个函数后面定义。若用extern在第一个函数前声明该变量则该变量可以在第一个函数中使用。多个文件中：在其他文件中若想要使用该文件中已声明的全局变量，则在其他文件头部声明该变量，即可使用该全局变量。file1.c file2.cint i,j; //定义全局变量 extern int i,j; //外部变量说明, extern可以省略char c; extern char c;void func() void func1(){ {i = 100; printf( i = %d, j = %d , i, j);j = 10;} }

不能！！！你说的是定义？还是声明？定义的时候，extern表示外部文件可以使用它，当然它至少得是全局的；全局变量默认是加上了extern的，与之相对的是static，它定义的全局变量，外部文件不能使用。声明的时候，它起一个扩展作用域的作用，它至少还是全局的，同一文件中，存在一个后面定义的全局变量，在文件开头添加一个extern的声明，前面的代码也可以使用这个变量了；其他的文件，在添加extern声明后，也可以使用它了。extern定义一个变量，与之相反的是static来定义，前者表示其他文件可以使用，后者表示其他文件不能使用。这些说的都是全局变量。局部变量定义的时候加上static是另外一个意思了，说的是该变量的存活期的问题，一直存在；这种情况下，没有extern的说法。

外部变量的意思

那个函数定义的时候就要加EXTERN的

在定义函数时，如果没有加关键字“static”，或冠以关键字“extern”，表示此函数是外部函数：[extern]nbsp;nbsp;函数类型nbsp;nbsp;函数名(函数参数表){……}调用外部函数时，需要对其进行说明：[extern]nbsp;nbsp;函数类型nbsp;nbsp;函数名(参数类型表)[，函数名2(参数类型表2)……]；[案例]外部函数应用。（1）文件mainf.cmain(){nbsp;nbsp;externnbsp;voidnbsp;input(…),process(…),output(…);input(…);nbsp;nbsp;process(…);nbsp;nbsp;output(…);}（2）文件subf1.c……externnbsp;nbsp;voidnbsp;input(……)nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;/*定义外部函数*/{……}（3）文件subf2.c……externnbsp;nbsp;voidnbsp;process(……)nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;/*定义外部nbsp;函数*/{……}（4）文件subf3.c……externnbsp;voidnbsp;output(……)nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;nbsp;/*定义外部函数*/{……} 查看原帖>>

extern是全局变量声明只要声明全局变量就默认 前面加extern（程序员可以不加，但编译器默认加上）若本文件 引用别的文件中的全局变量 一定要加上extern 声明一下例如 #include "my_Fun.c"extern int b;//b是在my_Fun.c中声明了的一个全局变量 这个extern 是个声明他可以在任何地方声明 引用了一个全局变量 （可以试试 在main()函数执行完之后声明 也不会出错）这样在 工程的总头文件中就不需要考虑 先#include 哪个文件了

extern是外部变量，当几个文件include到一起编译时就要用这个申明来共用变量

你是用num里面的复制的话那输出3的也是num里面的a如果想输出最外面的那个a那么num上面不用再定义一个a