学步园

1.

引言

　　C++
语言的创建初衷是“a
better C”
，但是这并不意味着C++
中类似C
语言的全局变量和函数所采用的编译和连接方式与C
语言完全相同。作为一种欲与C
兼容的语言，C++
保留了一部分过程 式语言的特点（被世人称为“
不彻底地面向对象”
），因而它可以定义不属于任何类的全局变量和函数。但是，C++
毕竟是一种面向对象的程序设计语言，为了支
持函数的重载，C++
对全局函数的处理方式与C
有明显的不同。

　　2.
从标准头文件说起

　　某企业曾经给出如下的一道面试题：

　　面试题


　　为什么标准头文件都有类似以下的结构？

#ifndef
__INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus
extern "C" {
#endif
/*...*/
#ifdef __cplusplus
}
#endif
#endif /* __INCvxWorksh */

　　分析


　　显然，头文件中的编译宏“#ifndef __INCvxWorksh
、#define __INCvxWorksh
、#endif”
的作用是防止该头文件被重复引用。

　　那么

#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
}
#endif

　　的作用又是什么呢？我们将在下文一一道来。

 

　　3.
深层揭密extern
"C"




　　extern "C"
包含双重含义，从字面上即可得到：首先，被它修饰的目标是“extern”
的；其次，被它修饰的目标是“C”
的。让我们来详细解读这两重含义。

　　被extern "C"
限定的函数或变量是extern
类型的；

　　extern
是C/C++
语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。记住，下列语句：

　　extern int a;

　　仅仅是一个变量的声明，其并不是在定义变量a
，并未为a
分配内存空间。变量a
在所有模块中作为一种全局变量只能被定义一次，否则会出现连接错误。

 

考虑下面的情况：

   

有两个头文件a.h main.cpp

一：

   
list: a.h

int a = 10;

 

   
list: main.cpp

#include <vector> #include <iostream> using namespace std ;   int main () {          std ::cout << a ; }

很显然，在编译main.cpp
的时候，由于无法获得a
的声明，无法通过。

二：

list: a.h

 

   
list: main.cpp

#include <vector> #include <iostream> using namespace std ;   extern int a ;   int main () {          std ::cout << a ; }

此时，a.h
是空的，main.cpp
可以编译通过，因为extern int a;
告诉编译器，a
是在其他模块里定义的一个int
变量，如此编译器就认为没问题了。但是在连接阶段，链接器到处都找不到这个a
的定义（在各个obj
文件中），所以就产生了链接错误。

三：

list: a.h

int a = 10;

 

   
list: main.cpp

#include <vector> #include <iostream> using namespace std ;   extern int a ;   int main () {          std ::cout << a ; }

想当然的，可能认为在这种情况下的话，肯定可以链接通过的。但其实，还是不行的。在a.h
中确实声明并定义了a
，但是其默认的作用域确是文件范围的，所以main.cpp
中的调用无法访问a.h
中的内容，所以链接还是失败了。

四：

list: a.h

extern int a ;

 

   
list: main.cpp

#include <vector> #include <iostream> using namespace std ;   extern int a ;   int main () {          std ::cout << a ; }

这种情况下，也还是链接不过的，因为在a.h
中，只是声明了a
是一个在外部被定义的变量，结果程序在链接的时候，还是到处找a
的定义而不得。

五：（注意）

list: a.h

extern int a = 10;

 

   
list: main.cpp

#include <vector> #include <iostream> using namespace std ;   extern int a ;   int main () {          std ::cout << a ; }

在这种情况下，可能认为肯定是可以了，因为在a.h
中，即声明并且定义了a
。但是，由于a.h
是一个头文件，在编译阶段它不会被编译成obj
文件，结果在链接时，链接器在一众obj
中还是找不到a
的定义，链接仍然失败，杯具啊...

六：（注意）

此时，引进a.cpp

list: a.h

list: a.cpp

int a = 20;

 

list: main.cpp

#include <vector> #include <iostream> using namespace std ;   extern int a ;   int main () {          std ::cout << a ; }

bingo!
编译链接通过了，这个结果可能又出人意料了。事实上，跟着前面的思路的话就不能理解了，在main.cpp
中，已经声明了a,
并且指定了它在别处被定义。这样编译器就认为没问题了，链接器其后从其他obj
中查找a
的定义，在a.obj
中，他发现了a
的定义，ok
，链接通过。

七：

list: a.h

int a ;

list: a.cpp

#include "a.h"   a = 20;

 

list: main.cpp

#include <vector> #include <iostream> using namespace std ;   extern int a ;   int main () {          std ::cout << a ; }

这个就是声明与定义的关系了。很显然，编不过。编译器在进行到a.h
时，发现了int a;
这看似一个普通的声明，但是编译器内部对这样的内置类型又进行了进一步的隐式定义。在编译a.cpp
时，由于a=20;
实在全局域中的，在全局域中你只能对变量进行声明或者声明且定义，所以a = 20;
时，编译器会认为你在声明一个变量，自然无法通过了。

　 　通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern
声明
。例如，如果模块B
欲引用该模块A
中定义的全局变量和函数 时只需包含模块A
的头文件即可。这样，模块B
中调用模块A
中的函数时，在编译阶段，模块B
虽然找不到该函数，但是并不会报错；它会在连接阶段中从模块A
编 译生成的目标代码中找到此函数。

如下：

list: a.h

extern int a ;   extern void func ();

list: a.cpp

int a = 10;   void func () { }

 

list: main.cpp

#include <vector> #include <iostream> using namespace std ;   #include "a.h"   int main () {          std ::cout << a ; }

　　与extern
对应的关键字是static
，被它修饰的全局变量和函数只能在本模块中使用。因此，一个函数或变量只可能被本模块使用时，其不可能被extern “C”
修饰。

　　被extern "C"
修饰的变量和函数是按照C
语言方式编译和连接的；

　　未加extern “C”
声明时的编译方式

　　首先看看C++
中对类似C
的函数是怎样编译的。

　　作为一种面向对象的语言，C++
支持函数重载，而过程式语言C
则不支持。函数被C++
编译后在符号库中的名字与C
语言