extern ，extern "C" 与 __cplusplus

冷不防 2022-02-17 10:05 307阅读 0赞

首先看下面几行代码：

#ifdef __cplusplus
    extern "C" {
    #endif
    
    .......(代码段)
    
    #ifdef __cplusplus
    } 
    #endif

上面这几行代码也许在平时经常看到，尤其是在大型的第三方库等代码中更为常见。

在c与c++的混合编译中更是不可或缺的，为了适应c与c++的编译方式的不同而产生的一种解决策略。

**上面几行代码大致分析：**

当 \_\_cplusplus被定义，也就是说当前文件为.cpp文件，即在c++环境中使用，这个识别是系统自动识别的，只要是c++代码，会默认定义\_\_cplusplus这个宏，当这个宏被定义之后，为了确保这些c代码在c++中可以正常使用，那么中间的代码段 中所有的代码的编译方式都将以c编译器的方式编译。

通过上述几行代码，有几个重点需要分析：**extern "C" \_\_cplusplus extern**

有些关键点网上资料解释的很是深入透彻。

# **一. extern "C"：** #

**定义：**

**作用：**主要作用就是为了能够正确实现C++代码调用其他C语言代码。加上extern "C"后，会指示编译器这部分代码按C语言的进行编译，而不是C++的

**示例分析**：

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

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

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

void foo(int x, int y);

该函数被C编译器编译后在符号库中的名字为\_foo，而C++编译器则会产生像\_foo\_int\_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangledname”）。\_foo\_int\_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y)编译生成的符号是不相同的，后者为\_foo\_int\_float。

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

**2.未加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这样的符号！

**3.加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的[目标代码][Link 4]时，没有对其名字进行特殊处理，采用了C语言的方式；

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

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

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

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

明白了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函数例子工程中包含的三个文件的[源代码][Link 6]如下：

/* 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.c"
    
    }
    
    int main(int argc, char* argv[])
    
    {
    
    add(2,3);
    
    return 0;
    
    }

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

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

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

//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 "cppExample.h" */
    
    extern int add( int x, int y );
    
    int main( int argc, char* argv[] )
    
    {
    
    add( 2, 3 );
    
    return 0;
    
    }

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

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

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

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

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

要明白为何使用extern "C"，还得从cpp中对函数的[重载][Link 8]处理开始说起。在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的方式来处理函数的，所以就会出现链接过不去的错误:因为[链接器][Link 9]找不到函数。

因此，为了在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"来说明。

# **二. \_\_cplusplus:** （前面是两个短\_） #

**定义：**它是一个定义好的宏，这个宏是在c++11里面新添加的特性，只要是cpp（c++代码）文件，这个宏就会被定义。

**作用：**主要是解决C/C++混合编程问题。

**定义者：**那么这个宏我们并看不到是什么内容，它是谁定义的呢？在网上查阅资料是发现一种答案：

\_\_cplusplus是微软自己搞的一个预定义宏。（Microsoft-Specific Predefined Macro），而微软的东西又是不容易看到源代码的。所以。。。

# **三. extern：** #

**定义：**编程语言中的一种属性，它表征了变量、函数等类型的作用域（可见性）属性，是编程语言中的关键字。

**作用：**当进行编译时，该关键字告诉编译器它所声明的函数和变量等可以在本模块或者文件以及其他模块或文件中使用。

**示例：**下面一个示例分析很深入的讲解了extern的作用

**1.声明外部变量**

现代[编译器][Link 10]一般采用按文件编译的方式，因此在编译时，各个文件中定义的[全局变量][Link 3]是互相不透明的。也就是说，在编译时，全局变量的可见域限制在文件内部。

下面举一个简单的例子：

创建一个工程，里面含有A.cpp和B.cpp两个简单的C++源文件：

//A.cpp
    
    int i;
    
    int main()
    
    {
        return 1;
    }
    
    //B.cpp
    
    int i;

我们对A和B分别编译，都可以正常通过编译，但是进行链接的时候，却出现了错误，错误提示如下：这两个文件极为简单，在A.cpp中我们定义了一个[全局变量][Link 3]i，在B中我们也定义了一个全局变量i。

Linking...
    
    B.obj:error LNK2005:"inti"(?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)

但是到了链接阶段，要将各个文件的内容“合为一体”，因此，如果某些文件中定义的全局变量名相同的话，在这个时候就会出现错误，也就是上面提示的重复定义的错误。这就是说，在编译阶段，各个文件中定义的[全局变量][Link 3]相互是不透明的，编译A时觉察不到B中也定义了i，同样，编译B时觉察不到A中也定义了i。

因此，各个文件中定义的全局变量名不可相同。

在链接阶段，各个文件的内容（实际是编译产生的obj文件）是被合并到一起的，因而，定义于某文件内的全局变量，在链接完成后，它的可见范围被扩大到了整个程序。

这样一来，按道理说，一个文件中定义的[全局变量][Link 3]，可以在整个程序的任何地方被使用，举例说，如果A文件中定义了某全局变量，那么B文件中应可以使用该变量。修改我们的程序，加以验证：

//A.cpp
    
    int 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)

其实出现这个错误是意料之中的，因为文件中定义的[全局变量][Link 3]的可见性扩展到整个程序是在链接完成之后，而在编译阶段，他们的可见性仍局限于各自的文件。编译错误。

[编译器][Link 10]的目光不够长远，编译器没有能够意识到，某个变量符号虽然不是本文件定义的，但是它可能是在其它的文件中定义的。

虽然编译器不够有远见，但是我们可以给它提示，帮助它来解决上面出现的问题。这就是extern的作用了。

extern的原理很简单，就是告诉编译器：“你现在编译的文件中，有一个标识符虽然没有在本文件中定义，但是它是在别的文件中定义的[全局变量][Link 3]，你要放行！”

我们为上面的错误程序加上extern关键字：

//A.cpp
    
    extern int i;
    
    int main()
    
    {
    
        i=100;//试图使用B中定义的全局变量
    
    }
    
    //B.cpp
    
    int i;

顺利通过编译，链接。

**2.函数前加extern：**

**extern函数1**

常见extern放在函数的前面成为函数声明的一部分，那么，[C语言][C 1]的[关键字][Link 11]extern在函数的声明中起什么作用？

答案与分析：

如果函数的声明中带有关键字extern，仅仅是暗示这个函数可能在别的源文件里定义，没有其它作用。即下述两个函数声明没有明显的区别：

extern int f(); 和int f();

当然，这样的用处还是有的，就是在程序中取代include “\*.h”来声明函数，在一些复杂的项目中，我比较习惯在所有的函数声明前添加extern修饰。

**extern函数2**

当函数提供方单方面修改函数原型时，如果使用方不知情继续沿用原来的extern申明，这样编译时[编译器][Link 10]不会报错。但是在运行过程中，因为少了或者多了输入参数，往往会造成系统错误，这种情况应该如何解决？

答案与分析：

目前业界针对这种情况的处理没有一个很完美的方案，通常的做法是提供放在自己的xxx\_pub.h中提供对外部[接口][Link 12]的声明，然后调用包涵该文件的头文件，从而省去extern这一步。以避免这种错误。

宝剑有双锋，对extern的应用，不同的场合应该选择不同的做法。

参考资料：百度百科，CSDN论坛，MSDN

[https://baike.baidu.com/item/extern%20%22C%22/15267013?fr=aladdin][https_baike.baidu.com_item_extern_20_22C_22_15267013_fr_aladdin]

[https://baike.baidu.com/item/extern/4443005?fr=aladdin][https_baike.baidu.com_item_extern_4443005_fr_aladdin]

[https://bbs.csdn.net/topics/60346481][https_bbs.csdn.net_topics_60346481]

[Link 1]: https://baike.baidu.com/item/%E5%B1%80%E9%83%A8%E5%8F%98%E9%87%8F
[Link 2]: https://baike.baidu.com/item/%E6%88%90%E5%91%98%E5%8F%98%E9%87%8F
[Link 3]: https://baike.baidu.com/item/%E5%85%A8%E5%B1%80%E5%8F%98%E9%87%8F
[Link 4]: https://baike.baidu.com/item/%E7%9B%AE%E6%A0%87%E4%BB%A3%E7%A0%81
[Link 5]: https://baike.baidu.com/item/%E6%B7%B7%E5%90%88%E7%BC%96%E7%A8%8B
[C]: https://baike.baidu.com/item/C%2B%2B%E5%BC%95%E7%94%A8
[Link 6]: https://baike.baidu.com/item/%E6%BA%90%E4%BB%A3%E7%A0%81
[Link 7]: https://baike.baidu.com/item/%E6%8E%A5%E5%8F%A3%E5%87%BD%E6%95%B0
[Link 8]: https://baike.baidu.com/item/%E9%87%8D%E8%BD%BD
[Link 9]: https://baike.baidu.com/item/%E9%93%BE%E6%8E%A5%E5%99%A8
[Link 10]: https://baike.baidu.com/item/%E7%BC%96%E8%AF%91%E5%99%A8
[C 1]: https://baike.baidu.com/item/C%E8%AF%AD%E8%A8%80
[Link 11]: https://baike.baidu.com/item/%E5%85%B3%E9%94%AE%E5%AD%97
[Link 12]: https://baike.baidu.com/item/%E6%8E%A5%E5%8F%A3
[https_baike.baidu.com_item_extern_20_22C_22_15267013_fr_aladdin]: https://baike.baidu.com/item/extern%20%22C%22/15267013?fr=aladdin
[https_baike.baidu.com_item_extern_4443005_fr_aladdin]: https://baike.baidu.com/item/extern/4443005?fr=aladdin
[https_bbs.csdn.net_topics_60346481]: https://bbs.csdn.net/topics/60346481