1、问题引出
最近在读com本质论时，第一章关于动态链接库调用缺点中提到了extern “c"的用法，顿时很不解，后来网上查资料了解到标准C++头文件中都会包含以下内容：
#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus
extern "C" {
#endif
/*...*/
#ifdef __cplusplus
}
#endif
#endif /* __INCvxWorksh */
顿时想起以前打开标准头文件时确有这样的代码？原来自己一直在用却浑然不知，于是在一博主名为一个人旅行的博客中找到了extern的用法解析，觉着写的非常好，而且简单易懂，所以就拿来主义一下。
分析
显然，头文件中的编译宏
“#ifndef __INCvxWorksh
、
#define __INCvxWorksh
、
#endif”
的作用是防止该头文件被重复引用。
那么
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
}
#endif
的作用又是什么呢？我们将在下文一一道来。
2、深层揭密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
及其它语言的混合编程。
3、
extern "C"的惯用法
明白了
C++
中
extern "C"
的设立动机，我们下面来具体分析
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); //注:写成extern "C" int add(int , int ); 也可以
#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" //注：此处不妥，如果这样编译通不过，换成 extern "C" int add(int , int ); 可以通过
}
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;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
