理解extern "C"

关于extern “C”的来龙去脉，摘录的三篇网友文章，如下：

http://www.yuanma.org/data/2006/0830/article_1438.htm

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在所有模块中作为一种全局变量只能被定义一次，否则会出现连接错误。

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

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

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

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

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

　　作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为:

void foo( int x, int y );

该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。

　　_foo_int_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。

同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全局变量名字不同。

未加extern "C"声明时的连接方式

　　假设在C++中，模块A的头文件如下：

// 模块A头文件　moduleA.h

#ifndef MODULE_A_H

#define MODULE_A_H

int foo( int x, int y );

#endif

在模块B中引用该函数：

// 模块B实现文件　moduleB.cpp

#include "moduleA.h"

foo(2,3);

　　实际上，在连接阶段，连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号！

加extern "C"声明后的编译和连接方式

加extern "C"声明后，模块A的头文件变为：

// 模块A头文件　moduleA.h

#ifndef MODULE_A_H

#define MODULE_A_H

extern "C" int foo( int x, int y );

#endif

在模块B的实现文件中仍然调用foo( 2,3 )，其结果是：

（1）模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；

（2）连接器在为模块B的目标代码寻找foo(2,3)调用时，寻找的是未经修改的符号名_foo。

　　如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo( int x, int y ) ，则模块B找不到模块A中的函数；反之亦然。

所以，可以用一句话概括extern “C”这个声明的真实目的（任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题）：

　　实现C++与C及其它语言的混合编程。

　　明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的使用技巧。

4、 extern "C"的惯用法

（1） 在C++中引用C语言中的函数和变量，在包含C语言头文件（假设为cExample.h时，需进行下列处理：

extern "C"

{

#include "cExample.h"

}

而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。

　　笔者编写的C++引用C函数例子工程中包含的三个文件的源代码如下：

/* c语言头文件：cExample.h */

#ifndef C_EXAMPLE_H

#define C_EXAMPLE_H

extern int add(int x,int y);

#endif

/* c语言实现文件：cExample.c */

#include "cExample.h"

int add( int x, int y )

{

return x + y;

}

// c++实现文件，调用add：cppFile.cpp

extern "C"

{

#include "cExample.h"

}

int main(int argc, char* argv[])

{

add(2,3);

return 0;

}

　　如果C++调用一个C语言编写的.DLL时，当包括.DLL的头文件或声明接口函数时，应加extern "C" {　}。

　　（2）在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件中将C++中定义的extern "C"函数声明为extern类型。

　　笔者编写的C引用C++函数例子工程中包含的三个文件的源代码如下：

//C++头文件 cppExample.h

#ifndef CPP_EXAMPLE_H

#define CPP_EXAMPLE_H

extern "C" int add( int x, int y );

#endif

//C++实现文件 cppExample.cpp

#include "cppExample.h"

int add( int x, int y )

{

return x + y;

}

/* C实现文件 cFile.c

/* 这样会编译出错：#include "cExample.h" */

extern int add( int x, int y );

int main( int argc, char* argv[] )

{

add( 2, 3 );

return 0;

}

　　如果深入理解了第3节中所阐述的extern "C"在编译和连接阶段发挥的作用，就能真正理解本节所阐述的从C++引用C函数和C引用C++函数的惯用法。对第4节给出的示例代码，需要特别留意各个细节。

http://www.yuanma.org/data/2006/0713/article_1126.htm　　

extern "C"的用法

链接指示符extern C

如果程序员希望调用其他程序设计语言尤其是C 写的函数，那么调用函数时必须

告诉编译器使用不同的要求。例如当这样的函数被调用时，函数名或参数排列的顺序可能

不同，无论是C++函数调用它还是用其他语言写的函数调用它。

程序员用链接指示符linkage directive 告诉编译器该函数是用其他的程序设计语言编写的，链接指示符有两种形式，既可以是单一语句single statement 形式也可以是复

合语句compound statement 形式：

// 单一语句形式的链接指示符

extern "C" void exit(int);

// 复合语句形式的链接指示符

extern "C" {

int printf( const char* ... );

int scanf( const char* ... );

}

// 复合语句形式的链接指示符

extern "C" {

#include <cmath>

}

链接指示符的第一种形式：由关键字extern 后跟一个字符串常量以及一个普通的函数

声明构成，虽然函数是用另外一种语言编写的但调用它仍然需要类型检查，例如编译器会检查传递给函数exit()的实参的类型是否是int ，或者能够隐式地转换成int 型。

多个函数声明可以用花括号包含在链接指示符复合语句中，这是链接指示符的第二种形

式。花招号被用作分割符，表示链接指示符应用在哪些声明上，在其他意义上该花括号被忽

略。所以，在花括号中声明的函数名对外是可见的，就好像函数是在复合语句外声明的一样。

例如，在前面的例子中复合语句extern "C"表示函数printf()和scanf()是在C 语言中写的函数，因此这个声明的意义就如同printf()和scanf()是在extern "C"复合语句外面声明的

一样。

当复合语句链接指示符的括号中含有#include 时，在头文件中的函数声明都被假定是用

链接指示符的程序设计语言所写的，在前面的例子中在头文件<cmath>中声明的函数都是C

函数。

链接指示符不能出现在函数体中，下列代码段将会导致编译错误：

int main()

{

// 错误:
链接指示符不能出现在函数内

extern "C" double sqrt( double );

305 第七章函数

double getValue(); //ok

double result = sqrt ( getValue() );

//...

return 0;

}

如果把链接指示符移到函数体外，程序编译将无错误：

extern "C" double sqrt( double );

int main()

{

double getValue(); //ok

double result = sqrt ( getValue() );

//...

return 0;

}

但是把链接指示符放在头文件中更合适，在那里函数声明描述了函数的接口所属，

如果我们希望C++函数能够为C 程序所用又该怎么办呢？我们也可以使用extern "C"

链接指示符来使C++函数为C 程序可用，例如：

// 函数calc()
可以被C
程序调用

extern "C" double calc( double dparm ) { /* ... */ }

如果一个函数在同一文件中不只被声明一次，则链接指示符可以出现在每个声明中，它

也可以只出现在函数的第一次声明中。在这种情况下，第二个及以后的声明都接受第一个声

明中链接指示符指定的链接规则，例如：

// ---- myMath.h ----

extern "C" double calc( double );

// ---- myMath.C ----

// 在Math.h
中的calc()
的声明

#include "myMath.h"

// 定义了extern "C" calc()
函数

// calc() 可以从C
程序中被调用

double calc( double dparm ) { // ...

在本节中，我们只看到为C 语言提供的链接指示extern "C"， extern "C"是惟一被保证由所有C++实现都支持的。每个编译器实现都可以为其环境下常用的语言提供其他链接指示。例如extern "Ada"可以用来声明是用Ada 语言写的函数，extern "FORTRAN"用来声明是用FORTRAN 语言写的函数，等等。因为其他的链接指示随着具体实现的不同而不同，所以建议读者查看编译器的用户指南以获得其他链接指示符的进一步信息
。

http://www.bc-cn.net/Article/kfyy/cjj/jszl/200602/3715.html

探索C++的秘密之详解extern "C"

　时常在cpp的代码之中看到这样的代码:

#ifdef __cplusplus extern "C" { #endif //一段代码 #ifdef __cplusplus } #endif

　　这样的代码到底是什么意思呢？首先，__cplusplus是cpp中的自定义宏，那么定义了这个宏的话表示这是一段cpp的代码，也就是说，上面的代码的含义是:如果这是一段cpp的代码，那么加入extern "C"{和}处理其中的代码。

　　要明白为何使用extern "C"，还得从cpp中对函数的重载处理开始说起。在c++中，为了支持重载机制，在编译生成的汇编码中，要对函数的名字进行一些处理，加入比如函数的返回类型等等.而在C中，只是简单的函数名字而已，不会加入其他的信息.也就是说:C++和C对产生的函数名字的处理是不一样的.

　　比如下面的一段简单的函数，我们看看加入和不加入extern "C"产生的汇编代码都有哪些变化:

int f(void) { return 1; }

　　在加入extern "C"的时候产生的汇编代码是:

.file "test.cxx" .text .align 2 .globl _f .def _f; .scl 2; .type 32; .endef _f: pushl %ebp movl %esp， %ebp movl $1， %eax popl %ebp ret

　　但是不加入了extern "C"之后

.file "test.cxx" .text .align 2 .globl __Z1fv .def __Z1fv; .scl 2; .type 32; .endef __Z1fv: pushl %ebp movl %esp， %ebp movl $1， %eax popl %ebp ret

　　两段汇编代码同样都是使用gcc -S命令产生的，所有的地方都是一样的，唯独是产生的函数名，一个是_f，一个是__Z1fv。

　　明白了加入与不加入extern "C"之后对函数名称产生的影响，我们继续我们的讨论:为什么需要使用extern "C"呢？C++之父在设计C++之时，考虑到当时已经存在了大量的C代码，为了支持原来的C代码和已经写好C库，需要在C++中尽可能的支持C，而extern "C"就是其中的一个策略。

　　试想这样的情况:一个库文件已经用C写好了而且运行得很良好，这个时候我们需要使用这个库文件，但是我们需要使用C++来写这个新的代码。如果这个代码使用的是C++的方式链接这个C库文件的话，那么就会出现链接错误.我们来看一段代码:首先，我们使用C的处理方式来写一个函数，也就是说假设这个函数当时是用C写成的:

//f1.c extern "C" { void f1() { return; } }

　　编译命令是:gcc -c f1.c -o f1.o 产生了一个叫f1.o的库文件。再写一段代码调用这个f1函数:

// test.cxx //这个extern表示f1函数在别的地方定义，这样可以通过 //编译，但是链接的时候还是需要 //链接上原来的库文件. extern void f1(); int main() { f1(); return 0; }

　　通过gcc -c test.cxx -o test.o 产生一个叫test.o的文件。然后，我们使用gcc test.o f1.o来链接两个文件，可是出错了，错误的提示是:

test.o(.text + 0x1f):test.cxx: undefine reference to 'f1()'

　　也就是说，在编译test.cxx的时候编译器是使用C++的方式来处理f1()函数的，但是实际上链接的库文件却是用C的方式来处理函数的，所以就会出现链接过不去的错误:因为链接器找不到函数。

　　因此，为了在C++代码中调用用C写成的库文件，就需要用extern "C"来告诉编译器:这是一个用C写成的库文件，请用C的方式来链接它们。

　　比如，现在我们有了一个C库文件，它的头文件是f.h，产生的lib文件是f.lib，那么我们如果要在C++中使用这个库文件，我们需要这样写:

extern "C" { #include "f.h" }

　　回到上面的问题，如果要改正链接错误，我们需要这样子改写test.cxx:

extern "C" { extern void f1(); } int main() { f1(); return 0; }

　　重新编译并且链接就可以过去了.



　　总结

　　C和C++对函数的处理方式是不同的.extern "C"是使C++能够调用C写作的库文件的一个手段，如果要对编译器提示使用C的方式来处理函数的话，那么就要使用extern "C"来说明。