解析“extern”

    技术2022-05-11  3

    <script type="text/javascript"> document.body.oncopy = function() { if (window.clipboardData) { setTimeout(function() { var text = clipboardData.getData("text"); if (text && text.length>300) { text = text + "/r/n/n本文来自博客,转载请标明出处:" + location.href; clipboardData.setData("text", text); } }, 100); } } </script> <script class="blogstory">function StorePage(){d=document;t=d.selection?(d.selection.type!='None'?d.selection.createRange().text:''):(d.getSelection?d.getSelection():'');void(keyit=window.open('http://www.365key.com/storeit.aspx?t='+escape(d.title)+'&u='+escape(d.location.href)+'&c='+escape(t),'keyit','scrollbars=no,width=475,height=575,left=75,top=20,status=no,resizable=yes'));keyit.focus();}</script>

    解析“ extern

    1、 声明外部变量

    现代编译器一般采用按文件编译的方式,因此在编译时,各个文件中定义的全局变量是

    互相透明的,也就是说,在编译时,全局变量的可见域限制在文件内部。下面举一个简单的例子。创建一个工程,里面含有 A.cpp B.cpp 两个简单的 C++ 源文件:

    //A.cpp

    int i;

     

    void main()

    {

    }

     

     

     

     

     

    //B.cpp

    int i;

     

     

          

    这两个文件极为简单,在 A.cpp 中我们定义了一个全局变量 i ,在 B 中我们也定义了一个全局变量 i

    我们对 A B 分别编译,都可以正常通过编译,但是进行链接的时候,却出现了错误,错误提示如下:

    Linking...

    B.obj : error LNK2005: "int i" (?i@@3HA) already defined in A.obj

    Debug/A.exe : fatal error LNK1169: one or more multiply defined symbols found

    Error executing link.exe.

     

    A.exe - 2 error(s), 0 warning(s)

     

     

     

     

     

           这就是说,在编译阶段,各个文件中定义的全局变量相互是透明的,编译 A 时觉察不到 B 中也定义了 i ,同样,编译 B 时觉察不到 A 中也定义了 i

    但是到了链接阶段,要将各个文件的内容“合为一体”,因此,如果某些文件中定义的全局变量名相同的话,在这个时候就会出现错误,也就是上面提示的重复定义的错误。

           因此,各个文件中定义的全局变量名不可相同。

     

          

           在链接阶段,各个文件的内容(实际是编译产生的 obj 文件)是被合并到一起的,因而,定义于某文件内的全局变量,在链接完成后,它的可见范围被扩大到了整个程序。

           这样一来,按道理说,一个文件中定义的全局变量,可以在整个程序的任何地方被使用,举例说,如果 A 文件中定义了某全局变量,那么 B 文件中应可以该变量。修改我们的程序,加以验证:

    //A.cpp

     

    void main()

    {

        i = 100; // 试图使用 B 中定义的全局变量

    }

     

     

     

     

     

    //B.cpp

    int i;

     

     

     

           编译结果如下:

     

          

    Compiling...

    A.cpp

    C:/Documents and Settings/wangjian/ 桌面 /try extern/A.cpp(5) : error C2065: 'i' : undeclared identifier

    Error executing cl.exe.

     

    A.obj - 1 error(s), 0 warning(s)

     

     

     

     

     

     

     

           编译错误。

           其实出现这个错误是意料之中的,因为:文件中定义的全局变量的可见性扩展到整个程序是在链接完成之后,而在编译阶段,他们的可见性仍局限于各自的文件。

           编译器的目光不够长远,编译器没有能够意识到,某个变量符号虽然不是本文件定义的,但是它可能是在其它的文件中定义的。

          

           虽然编译器不够远见,但是我们可以给它提示,帮助它来解决上面出现的问题。这就是 extern 的作用了。

           extern 的原理很简单,就是告诉编译器:“你现在编译的文件中,有一个标识符虽然没有在本文件中定义,但是它是在别的文件中定义的全局变量,你要放行!”

           我们为上面的错误程序加上 extern 关键字:

    //A.cpp

     

    extern int i;

    void main()

    {

        i = 100; // 试图使用 B 中定义的全局变量

    }

     

     

     

     

     

     

    //B.cpp

    int i;

     

     

     

           顺利通过编译,链接。

     

     

    2、 C++ 文件中调用 C 方式编译的函数

     

    C 方式编译和 C++ 方式编译

    相对于 C C++ 中新增了诸如重载等新特性,对于他们的编译,必然有一些重要的区别。

    我们将下面的小程序分别按 C C++ 方式编译,来探讨两种编译方式的区别。

    int i;

     

    int func(int t)

    {

             return 0;

    }

     

    void main()

    {

    }

     

     

     

     

     

     

     

     

           C 方式编译的结果:

    COMM     _i  :  DWORD

     

    PUBLIC    _func

     

    PUBLIC    _main

     

     

     

     

     

           C++ 方式编译的结果:

    PUBLIC    ?i@@3HA                                               ; i

     

    PUBLIC    ?func@@YAHH@Z                                         ; func

     

    PUBLIC    _main

     

     

     

     

     

           可见, C 方式编译下,变量名和函数名之前被统一加上了一个下划线,而 C++ 编译后的结果却复杂的多, i 变成了 ?i@@3HA func 变成了 ?func@@YAHH@Z C++ 中的这种看似复杂的命名规则是为 C++ 中的函数重载,参数检查等特性服务的。

     

    多文件程序中的函数调用

           一般情况下,工程中的文件都是 CPP 文件(以及头文件)。如下面的程序仅包含两个文件: A.CPP B.CPP

    //A.CPP

    void func();

     

    void main()

    {

             func();

    }

     

     

     

     

     

     

    //B.CPP

    void func()

    {

    }

     

     

     

     

           程序的结构是这样的:在文件 B.CPP 中定义了一个函数 void func() main 函数位于文件 A.CPP ,在 main 函数中调用了 B 中定义的函数 func()

           要在 A 中调用 B 中定义的函数,必须要加上该函数的声明。如本例中的 void func(); 就是对函数 func() 的声明。

    如果没有声明的话,编译 A.CPP 时就会出错。因为编译器的目光只局限于被编译文件,必须通过加入函数声明来告诉编译器:“某个函数是定义在其它的文件中的,你要放行!”,这一点跟用 extern 来声明外部全局变量是一个道理。

           需要注意的是,一般的程序都是通过包含头文件来完成函数的声明。拿本例来说,一般是创建一个头文件 B.H ,在头文件中加入声明语句 void func(); 并且在 A.CPP 中加入包含语句: #include “B.H”

           C++ 程序中,头文件的功能从函数声明被扩展为类的定义。

     

    不同编译方式下的函数调用

           如果在工程中,不仅有 CPP 文件,还有以 C 方式编译的 C 文件,函数调用就会有一些微妙之处。我们将 B.CPP 改作 B.C

     

     

     

    //A.CPP

    void func();

     

    void main()

    {

             func();

    }

     

     

     

     

     

     

    //B.C

    void func()

    {

    }

     

     

     

     

           A.CPP B.C 分别编译,都没有问题,但是链接时出现错误。

    Linking...

    A.obj : error LNK2001: unresolved external symbol "void __cdecl func(void)" (?func@@YAXXZ)

    Debug/A.exe : fatal error LNK1120: 1 unresolved externals

    Error executing link.exe.

     

    A.exe - 2 error(s), 0 warning(s)

     

     

     

     

     

    原因就在于不同的编译方式产生的冲突。

     

           对于文件 A ,是按照 C++ 的方式进行编译的,其中的 func() 调用被编译成了

    call    ?func1@@YAXXZ    

     

     

    如果 B 文件也是按照 C++ 方式编译的,那么 B 中的 func 函数名也会被编译器改成 ?func1@@YAXXZ ,这样的话,就没有任何问题。

           但是现在对 B 文件,是按照 C 方式编译的, B 中的 func 函数名被改成了 _func ,这样一来, A 中的 call ?func1@@YAXXZ 这个函数调用就没有了着落,因为在链接器看来, B 文件中没有名为 ?func1@@YAXXZ 的函数。

           事实是,我们编程者知道, B 文件中有 A 中调用的 func 函数的定义,只不过它是按照 C 方式编译的,故它的名字被改成了 _func 。因而,我们需要通过某种方式告诉编译器:“ B 中定义的函数 func() 经编译后命名成了 _func ,而不是 ?func1@@YAXXZ ,你必须通过 call _func 来调用它,而不是 call ?func1@@YAXXZ 。”简单的说,就是告诉编译器,调用的 func() 函数是以 C 方式编译的, fun(); 语句必须被编译成 call _func; 而不是 call ?func1@@YAXXZ

          

           我们可以通过 extern 关键字,来帮助编译器解决上面提到的问题。

           对于本例,只需将 A.CPP 改成如下即可:

    //A.CPP

    extern "C"

    {

             void func();

    }

    void main()

    {

             func();

    }

     

          

     

     

     

     

     

     

           察看汇编代码,发现此时的 func(); 语句被编译成了 call _func

    3、 补充

    2 一样,仍然是 C C++ 混合编程的情形,考虑下面的程序:

    //A.CPP

     

    extern int i;

     

    void main()

    {

             i = 100;

    }

     

     

     

     

     

     

     

    //B.C

    int i;

     

     

           程序很简单:在文件 B.C 中定义了一个全局变量 i ,在 A.CPP 中使用了这个全局变量。

           编译没有问题,链接时却出现错误:

    Linking...

    A.obj : error LNK2001: unresolved external symbol "int i" (?i@@3HA)

    Debug/A.exe : fatal error LNK1120: 1 unresolved externals

    Error executing link.exe.

     

    A.exe - 2 error(s), 0 warning(s)

     

     

     

     

     

          

           这是因为,在 C 方式编译下, i 被重命名为 _i ,而在 C++ 方式下, i 会被重命名为 ?i@@3HA

    因而,我们只用 extern int i; 来声明还不够,必须告诉编译器,全局变量 i 是以 C 方式编译的,

    它会被重命名为 _i ,而不是 ?i@@3HA

     

           我们修改 A.CPP ,如下:

    //A.CPP

     

    extern "C"

    {

             int i;

    }

    void main()

    {

     

             i = 100;

    }

     

     

     

     

     

     

     

     

     

           程序正常通过编译和链接。

           我们察看一下汇编代码,发现语句 i = 100; 被编译成了 mov  DWORD PTR _i, 100

     

     

    转自:http://blog.csdn.net/keensword/archive/2005/06/23/401114.aspx


    最新回复(0)