精华内容
下载资源
问答
  • ,对变量来说,必须加extern才是引用声明,对函数来说,函数声明默认就是extern。 当不包含头文件而希望访问其他源文件的外部变量或者外部函数时时,都必须提前对他做引用声明,才能使用外部变量或函数,如: 在...

    两种声明:
    1.定义声明:简称定义,编译器给变量分配存储空间;
    2.引用声明:简称声明,编译器不分配存储空间,但可引用已定义的变量。
    声明可以多次,但是定义只能一次,对变量来说,必须加extern才是引用声明,对函数来说,函数声明默认就是extern。

    当在不include含有全局变量或函数定义的头文件时,而这个全局变量或函数在某个源文件存在定义,则使用它之前都必须提前对他做引用声明才能使用此外部全局变量或函数,如:
    在definition.cpp里定义声明
    int blem = 3;
    int fun(int a, int b)
    {
    return a + b;
    }
    在externdefinition.cpp做引用声明:
    extern int blem;
    int fun(int a,int b);
    这样就可以在externdefinition.cpp使用定义好的变量或函数了。
    definition.cpp如下:
    definition.cpp文件
    externdefinition.cpp如下:
    在这里插入图片描述
    运行结果如下:
    在这里插入图片描述
    需注意的是:
    1.如果在同一工程下的其他源文件中,使用外部全局变量而不加extern,则变成了一种定义声明,同一工程下,不允许同一变量的多个定义。
    2.如果在externdefinition.cpp中定义了局部变量,则将隐藏外部全局变量声明,此时可以通过作用域解析运算符(::)就可以使用变量的全局版本。
    3.局部变量的声明不能有extern的修饰,局部变量在运行时才在堆栈部分分配内存。
    4.extern对静态全局变量和静态全局函数不起任何作用。

    展开全文
  • extern使用方法总结!

    万次阅读 多人点赞 2018-08-07 19:45:55
    一、问题 Extern的问题在于不知道这个...2、全局变量在外部使用声明时,extern关键字是必须的,如果变量没有extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加extern,而编译器在此标记存储空间在...

    一、问题
    Extern的问题在于不知道这个关键词出现的时候到底是声明还是定义?

     

    二、详解
    1、函数的声明extern关键词是可有可无的,因为函数本身不加修饰的话就是extern。但是引用的时候一样需要声明的。

    2、全局变量在外部使用声明时,extern关键字是必须的,如果变量没有extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加extern,而编译器在此标记存储空间在执行时加载内并初始化为0。而局部变量的声明不能有extern的修饰,且局部变量在运行时才在堆栈部分分配内存。

    3、全局变量或函数本质上讲没有区别,函数名是指向函数二进制块开头处的指针。而全局变量是在函数外部声明的变量。函数名也在函数外,因此函数也是全局的。

    4、谨记:声明可以多次,定义只能一次

    5、extern int i; //声明,不是定义
    int i; //声明,也是定义

     

    三、示例

    1、代码

    /* test.c */
    #include <stdio.h>
    
    int etn = 100;
    
    void layout()
    {
        printf("test.c: The etn is %d\n", etn);
    }
    /* main.c */
    #include <stdio.h>
    
    extern int etn;
    
    int main()
    {
        layout();
        printf("main.c: The etn is %d\n", etn);
        return 0;
    }

    2、运行结果

     

    参考

    1、extern使用方法总结!

    2、C--变量的作用域、存储方式与生命周期

     

     

     

     

     

     

     

    展开全文
  • extern用法

    2017-02-04 17:27:00
    全局变量在外部使用声明时,extern关键词是必须的,如果变量无extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加extern,而编译器在此标记存储空间在执行时加载如内存并初始化为0。 局部变量的...

    谨记:声明可以多次,定义只能一次。

    函数的声明extern关键词是可有可无的,因为函数本身不加修饰的话就是extern的。但是引用的时候一样是需要声明的。

    全局变量在外部使用声明时,extern关键词是必须的,如果变量无extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加extern,而编译器在此标记存储空间在执行时加载如内存并初始化为0。

    局部变量的声明不能有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_头文件.H
    int A;
    #endif

    那么,很糟糕的是,这里的int A是个全局变量的定义,所以如果这个头文件被多次引用的话,你的A会被重复定义
    显然语法上错了。只不过有了这个#ifndef的条件编译,所以能保证你的头文件只被引用一次,不过也许还是会岔子,但若多个c文件包含这个头文件时还是会出错的,因为宏名有效范围仅限于本c源文件,所以在这多个c文件编译时是不会出错的,但在链接时就会报错,说你多处定义了同一个变量。

     

     

    extern

     

    这个关键字真的比较可恶,在声明的时候,这个extern居然可以被省略,所以会让你搞不清楚到底是声明还是定义,下面分变量和函数两类来说:

     

    (1)变量

     

    尤其是对于变量来说。
    extern int a;//声明一个全局变量a
    int a; //定义一个全局变量a

    extern 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。

     

    http://blog.csdn.net/liu1028701143/article/details/7359381

     

     

    转载于:https://www.cnblogs.com/TurboLemon/p/6365964.html

    展开全文
  • extern详解

    2017-07-20 10:14:25
    Extern的问题在于不知道这个关键词出现的时候到底是声明还是定义。...而全局变量在外部使用声明时,extern关键词是必须的,如果变量无extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加

    Extern的问题在于不知道这个关键词出现的时候到底是声明还是定义。

    谨记:声明可以多次,定义只能一次。


    函数的声明extern关键词是可有可无的,因为函数本身不加修饰的话就是extern的。但是引用的时候一样是需要声明的。

    而全局变量在外部使用声明时,extern关键词是必须的,如果变量无extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加extern,而编译器在此标记存储空间在执行时加载如内存并初始化为0。而局部变量的声明不能有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_头文件.H
    int A;
    #endif
    那么,很糟糕的是,这里的int A是个全局变量的定义,所以如果这个头文件被多次引用的话,你的A会被重复定义,显然语法上错了。只不过有了这个#ifndef的条件编译,所以能保证你的头文件只被引用一次,不过也许还是会岔子,但若多个c文件包含这个头文件时还是会出错的,因为宏名有效范围仅限于本c源文件,所以在这多个c文件编译时是不会出错的,但在链接时就会报错,说你多处定义了同一个变量,

    Linking...
    incl2.obj : error LNK2005: "int glb" (?glb@@3HA) already defined in incl1.obj
    Debug/incl.exe : fatal error LNK1169: one or more multiply defined symbols found

    注意!!!

    extern

    这个关键字真的比较可恶,在声明的时候,这个extern居然可以被省略,所以会让你搞不清楚到底是声明还是定义,下面分变量和函数两类来说:

    (1)变量

    尤其是对于变量来说。
    extern int a;//声明一个全局变量a
    int a; //定义一个全局变量a

    extern 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.

    struct per_rec

    int age;
    char *surname;
    char *firstname;

    };

    int a;
    char c;
    struct per_rec person;

    A construct which specifies the name,parameters and return type of a function. For example a function definition would be:

    long sqr(int num)
    {
    return(num*num);
    }

    前者是"定义性声明(defining declaration)"或者称为"定义(definition)",而后者是"引用性声明(referncing declaration)" 。从广义的角度来讲 声明中包含着定义,但是并非所有的声明都是定义,例如:int a 它既是声明,同时又是定义。然而对于 extern a 来讲它只是声明不是定义。它可以在同一源程序或不同的源程序中重复声明。一般的情况下我们常常这样叙述,把建立空间的声明称之为"定义",而把不需要建立存储空间称之为"声明"。很明显我们在这里指的声明是范围比较窄的,也就是说非定义性质的声明。
    例如:在主函数中

    int main()

    int a; //这里是定义(分配空间的声明),它不能重复出现
    //这里若写extern int a;或 int a;在VC6.0中编译均报错重复定义

      //(redefinition)

      //这里写int a;在DEV-C++中编译报错重复声明(redeclaration)
      //这里写extern int a;在DEV-C++中编译、运行均无问题
    extern int A; //这是个声明而不是定义,声明A是一个已经定义了的外部变量
      //注意:声明外部变量时可以把变量类型去掉如:extern A;
    dosth(); //执行函数

    int A;   //是定义,定义了A为整型的外部变量

    看来定义还是声明有时与编译器的处理也有关系。

    外部变量的"定义"与外部变量的"声明"是不相同的,外部变量的定义只能有一次,它的位置是在所有函数之外,而同一个文件中的外部变量声明可以是多次的,它可以在函数之内(哪个函数要用就在那个函数中声明)也可以在函数之外(在外部变量的定义点之前)。系统会根据外部变量的定义(而不是根据外部变量的声明)分配存储空间的。对于外部变量来讲,初始化只能是在"定义"中进行,而不是在"声明"中。
    所谓的"声明",其作用,是声明该变量是一个已在后面定义过的外部变量,仅仅是在为了"提前"引用该变量而作的"声明"而已。 extern 只作声明,不作任何定义 。


    #include "stdafx.h"
    1.extern用在变量声明中常常有这样一个作用,你在*.c文件中声明了一个全局的变量,这个全局的变量如果要被引用,就放在*.h中并用extern来声明。
    2.如果函数的声明中带有关键字extern,仅仅是暗示这个函数可能在别的源文件里定义,没有其它作用。即下述两个函数声明没有区别:
    extern int f(); 和int f();
    =================================
    1.如果定义函数的c/cpp文件在对应的头文件中声明了定义的函数,那么在其他c/cpp文件中要使用这些函数,只需要包含这个头文件即可。
    2.如果你不想包含头文件,那么在c/cpp中声明该函数。一般来说,声明定义在本文件的函数不用“extern”,声明定义在其他文件中的函数用“extern”,这样在本文件中调用别的文件定义的函数就不用包含头文件
    include “*.h”来声明函数,声明后直接使用即可。
    =================================
    举个例子:
    //extern.cpp内容如下:
    // extern.cpp : Defines the entry point for the console application.
    #include "stdafx.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);
    }
    结果程序可以正常运行,输出结果。如果把“extern”去掉,程序依然可以正常运行。

    由此可见,“extern”在函数声明中可有可无,只是用来标志该函数在本文件中定义,还是在别的文件中定义。只要你函数在使用之前声明了,那么就可以不用包含头文件了。

    在C语言中,修饰符extern用在变量或者函数的声明前,用来说明“此变量/函数是在别处定义的,要在此处引用”。





    0. 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声明只能用于文件作用域似的。

    1. 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程序编译过程中,这种差异是非常明显的。

    2. 此外,extern修饰符可用于指示C或者C++函数的调用规范。比如在C++中调用C库函数,就需要在C++程序中用extern “C”声明要引用的函数。这是给链接器用的,告诉链接器在链接的时候用C函数规范来链接。主要原因是C++和C程序编译完成后在目标代码中命名规则不同

    展开全文
  • extern的用法

    2020-12-22 09:00:57
    2、全局变量在外部使用声明时,extern关键字是必须的,如果变量没有extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加extern,而编译器在此标记存储空间在执行时加载内并初始化为0。而局部变量的...
  • 关键字 extern

    2017-03-23 16:59:57
    Extern的问题在于不知道这个关键词出现的时候到底是声明还是定义。...而全局变量在外部使用声明时,extern关键词是必须的,如果变量无extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加ext
  • extern关键字详解

    2018-04-01 22:54:46
    Extern的问题在于不知道这个关键词出现...而全局变量在外部使用声明时,extern关键词是必须的,如果变量无extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加extern,而编译器在此标记存储空间在执...
  • extern关键词用法

    2018-03-28 11:42:04
    Extern的问题在于不知道这个关键词出现...而全局变量在外部使用声明时,extern关键词是必须的,如果变量无extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加extern,而编译器在此标记存储空间在执...
  • extern用法总结

    2014-12-15 09:23:43
    Extern的问题在于不知道这个关键词出现的时候到底是声明还是定义。...而全局变量在外部使用声明时,extern关键词是必须的,如果变量无extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加extern
  • extern使用方法总结

    2020-03-04 22:22:49
    一、问题 ...2、全局变量在外部使用声明时,extern关键字是必须的,如果变量没有extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加extern,而编译器在此标记存储空间在执行时加载...
  • 而全局变量在外部使用声明时,extern关键词是必须的,如果变量无extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加extern,而编译器在此标记存储空间在执行时加载如内存并初始化为0。 而局部变量...
  • 2、全局变量在外部使用声明时,extern关键字是必须的,如果变量没有extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加extern,而编译器在此标记存储空间在执行时加载内并初始化为0。而局部变量的...
  • extern的使用方法

    2017-05-07 23:49:25
    Extern的问题在于不知道这个关键词出现的时候到底是声明还是定义。...而全局变量在外部使用声明时,extern关键词是必须的,如果变量无extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须
  • Extern的问题在于不知道这个关键词出现的时候到底是声明还是...而全局变量在外部使用声明时,extern关键词是必须的,如果变量无extern修饰且没有显式的初始化,同样成为变量的定义,因此此时必须加extern,而编译器在此

空空如也

空空如也

1 2 3
收藏数 52
精华内容 20
关键字:

外部引用必须加extern