extern作用详解

「爱情、让人受尽委屈。」 2022-09-17 15:26 160阅读 0赞

出处：[http://blog.csdn.net/songjinshi/article/details/6785267][http_blog.csdn.net_songjinshi_article_details_6785267]

extern 作用1：**声明外部变量**  
现代编译器一般采用按文件编译的方式，因此在编译时，各个文件中定义的全局变量是  
互相透明的，也就是说，在编译时，全局变量的可见域限制在文件内部。  
  
例1：  
创建一个工程，里面含有A.cpp和B.cpp两个简单的C++源文件：  
//A.cpp:  
int iRI;  
int main()  
\{  
//.....  
\}  
  
//B.cpp  
int iRI;  
  
gcc A.cpp -c  
gcc B.cpp -c  
编译出A.o, B.o都没有问题。  
但当gcc A.o B.o -o test时，  
main.o:(.bss+0x0): multiple definition of \`iRI'  
b.o:(.bss+0x0): first defined here  
报错：重定义。  
**（但有个非常意外的发现：当同样的代码，使用A.c B.c.并使用gcc编译时，竟然不会报重定义的错误，非常不明白是怎么回事。）**  
这就是说，在编译阶段，各个文件中定义的全局变量相互是透明的，编译A时觉察不到B中也定义了i，同样，编译B时觉察不到A中也定义了i。  
但是到了链接阶段，要将各个文件的内容“合为一体”，因此，如果某些文件中定义的全局变量名相同的话，在这个时候就会出现错误，也就是上面提示的重复定义的错误。因此，各个文件中定义的全局变量名不可相同。  
  
但如果用下列方式：在B.cpp中定义iRI;在A.cpp中直接使用。则编译A.cpp时就无法通过。  
//A.cpp  
int main()  
\{  
iRI=64;  
\}  
  
//B.cpp  
int iRI;  
  
gcc A.cpp -c  
was not declared in this scope.

因为编译器按照文件方式编译，所以编译A.cpp时，并不知道B.cpp中定义了iRI。  
也就是说：文件中定义的全局变量的可见性扩展到整个程序是在链接完成之后，而在编译阶段，他们的可见性仍局限于各自的文件。  
**解决方案如下：**  
编译器的目光不够长远，编译器没有能够意识到，某个变量符号虽然不是本文件定义的，但是它可能是在其它的文件中定义的。  
虽然编译器不够远见，但是我们可以给它提示，帮助它来解决上面出现的问题。这就是extern的作用了。  
**extern的原理很简单，就是告诉编译器：“你现在编译的文件中，有一个标识符虽然没有在本文件中定义，但是它是在别的文件中定义的全局变量，你要放行！”**  
//A.cpp:  
extern int iRI;  
int main()  
\{  
iRI = 64;  
//.....  
\}  
  
//B.cpp  
int iRI;  
这样编译就能够通过。  
extern int iRI; //并未分配空间，只是通知编译器，在其它文件定义过iRI。  
  
  
**extern 作用2：在C++文件中调用C方式编译的函数**  
C方式编译和C++方式编译  
相对于C，C++中新增了诸如重载等新特性。所以全局变量和函数名编译后的命名方式有很大区别。  
int a;  
int functionA();  
对于C方式编译：  
int a;=> \_a  
int functionA(); => \_functionA  
对于C++方式编译：  
int a; =>xx@xxx@a  
int functionA(); => [xx@xx@functionA][xx_xx_functionA]  
可以看出，因为要支持重载，所以C++方式编译下，生成的全局变量名和函数名复杂很多。与C方式编译的加一个下划线不同。  
于是就有下面几种情况：  
例2：C++调用C++定义的全局变量  
//A.cpp:  
extern int iRI;  
int main()  
\{  
iRI = 64;  
//.....  
\}  
//B.cpp  
int iRI;  
gcc A.cpp -c  
gcc B.cpp -c  
gcc A.o B.o -o test  
那么在编译链接时都没问题。  
  
例3：C++调用C定义的全局变量  
//A.cpp:  
extern int iRI;  
int main()  
\{  
iRI = 64;  
//.....  
\}  
//B.c  
int iRI;  
编译时没有问题，  
gcc A.cpp -c  
gcc B.c -c  
但链接时，gcc B.o A.o -o test  
则会报iRI没有定义。为什么呢？  
因为gcc看到A.cpp，就使用C++方式编译，看到B.c，就使用C方式编译。  
所以在A.cpp中的iRI=>XXX@XXX\_iRI;  
而B.c中iRI=〉\_iRI;  
所以在链接时，A.cpp想找到[XXX@XXX\_iRI][XXX_XXX_iRI]，当然找不到。所以就需要告诉编译器，iRI是使用C方式编译的。  
//A.cpp:  
extern "C"  
\{  
int iRI;  
\}  
int main()  
\{ iRI = 64;  
//.....  
\}  
//B.c  
int iRI;  
这样，当编译A.cpp时，编译器就知道iRI为C方式编译的。就会使用 \_iRI。这样B.c提供的\_iRI就可以被A.cpp找到了。  
  
**例4：C++调用C定义的function**  
//A.cpp  
extern int functionA();  
  
int main()  
\{  
functionA();  
\}  
  
//B.c  
int functionA()  
\{  
//....  
\}  
gcc A.cpp -c  
gcc B.c -c  
都没有问题。但同样的，gcc A.o B.o -o test  
则报错，找不到functionA();  
这是因为gcc将A.cpp认为是C++方式编译，B.c是C方式编译。  
所以functionA在B.c中为：\_functionA. 在A.cpp中为：[XX@XXX\_functionA][XX_XXX_functionA]  
所以在链接时A.cpp找不到[XX@XX\_function][XX_XX_function].  
于是需要通知编译器，functionA()是C方式编译命名的。  
//A.cpp  
extern "C"  
\{  
int functionA();  
\}  
int main()  
\{  
functionA();  
\}  
  
//B.c  
int functionA()  
\{  
//....  
\}  
于是，编译链接都可以通过。

总结：

extern "C"  
\{  
functionA();  
\}//不止是声明，并且还指出：这个function请用C方式编译。所以不需要再次extern.  
extern"C"  
\{  
extern functionA();  
\}//这样做没什么太大意义。

[http_blog.csdn.net_songjinshi_article_details_6785267]: http://blog.csdn.net/songjinshi/article/details/6785267
[xx_xx_functionA]: mailto:xx@xx@functionA
[XXX_XXX_iRI]: mailto:XXX@XXX_iRI
[XX_XXX_functionA]: mailto:XX@XXX_functionA
[XX_XX_function]: mailto:XX@XX_function