解析“extern”

此文转载至http://blog.csdn.net/keensword/archive/2005/06/23/401114.aspx

 

解析“ 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 。