Linux C/C++学习3：extern “C“的作用

最新推荐文章于 2024-07-30 14:44:20 发布

回笼觉觉父

最新推荐文章于 2024-07-30 14:44:20 发布

阅读量1.3k

点赞数

分类专栏： Linux C/C++ 文章标签： c++ linux extern cpp

本文链接：https://blog.csdn.net/weixin_42997255/article/details/121435854

版权

Linux C/C++ 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Linux C/C++学习3：extern "C"的作用

1. extern "C"概述

extern "C"的主要作用就是实现在C++代码中调用其他C代码，格式如下，其中__cplusplus为C++编译器默认定义的宏，code block部分为C语言实现代码。extern "C"会指示编译器这部分代码按C语言（而不是C++）进行编译。

#ifndef __cplusplus
    extern "C" {
#endif
	/* ... code block ... */
#ifndef __cplusplus
    }
#endif

2. extern "C"使用说明

2.1. C++调用C案例

参见附录A中的源码实例，其中extern "C"的使用详见demo2.h中的注释。在A.1所示源码结构的当前路径执行如下操作。

编译C实现源码demo2，生成目标文件demo2.o：
gcc -Wall ./demo_c/demo2.c -c -o ./build/demo2.o
编译C++实现源码demo1，生成目标文件demo1.o：
g++ -Wall ./demo_cpp/demo1.cpp -c -o ./build/demo1.o -I./demo_c
生成最终的可执行文件demo，并执行：
g++ -Wall ./build/*.o -o ./build/demo

root@ubuntu:/opt/extern_tmp# gcc -Wall ./demo_c/demo2.c -c -o ./build/demo2.o
root@ubuntu:/opt/extern_tmp# g++ -Wall ./demo_cpp/demo1.cpp -c -o ./build/demo1.o -I./demo_c
root@ubuntu:/opt/extern_tmp# g++ -Wall ./build/*.o -o ./build/demo
root@ubuntu:/opt/extern_tmp# ls ./build
demo  demo1.o  demo2.o
root@ubuntu:/opt/extern_tmp# ./build/demo 
a+b=2
a-b=0
root@ubuntu:/opt/extern_tmp#

2.2. C调用C++案例

当在C源码中调用C++库时，可以采用二次封装中间接口库的方式。参见附录B中的源码实例，其中extern "C"的使用详见mid.cpp中的注释。在B.1所示源码结构的当前路径执行如下操作。

编译C++实现源码demo2，生成共享库libdemo2.so：
g++ -Wall -shared -fPIC ./demo_cpp/demo2.cpp -o ./build/libdemo2.so
编译中间接口文件mid.cpp和libdemo2.so，二次封装生成中间接口库libdemo2_mid.so：
g++ -Wall -shared -fPIC ./build/libdemo2.so ./demo_c/mid.cpp -o ./build/libdemo2_mid.so -I./demo_cpp/
编译C实现源码demo1，调用libdemo2_mid.so和libdemo2.so两个共享库，生成可执行文件demo：
gcc -Wall ./demo_c/demo1.c -o ./build/demo -L./build/ -ldemo2_mid -ldemo2
执行demo可执行文件，发现没有找到libdemo2_mid.so，添加共享库路径（参见笔者另一篇文章静态库与动态库），并再次执行：
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/extern_tmp1/build/
echo $LD_LIBRARY_PATH
./build/demo

root@ubuntu:/opt/extern_tmp1# g++ -Wall -shared -fPIC ./demo_cpp/demo2.cpp -o ./build/libdemo2.so
root@ubuntu:/opt/extern_tmp1# g++ -Wall -shared -fPIC ./build/libdemo2.so ./demo_c/mid.cpp -o ./build/libdemo2_mid.so -I./demo_cpp/
root@ubuntu:/opt/extern_tmp1# gcc -Wall ./demo_c/demo1.c -o ./build/demo -L./build/ -ldemo2_mid -ldemo2
root@ubuntu:/opt/extern_tmp1# ls ./build/
demo  libdemo2_mid.so  libdemo2.so
root@ubuntu:/opt/extern_tmp1# ./build/demo
./build/demo: error while loading shared libraries: libdemo2_mid.so: cannot open shared object file: No such file or directory
root@ubuntu:/opt/extern_tmp1# export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/extern_tmp1/build/
root@ubuntu:/opt/extern_tmp1# echo $LD_LIBRARY_PATH
:/opt/extern_tmp1/build/
root@ubuntu:/opt/extern_tmp1# ./build/demo
c++ implements a+b
a+b=2
root@ubuntu:/opt/extern_tmp1#

2.3. extern "C"使用要点

单一语句形式：

extern "C" int add(int a, int b);

复合语句形式，相当于复合语句中的声明都加了extern “C”：

extern "C"
{
      int add(int a, int b);
      double sub(double a, float b);
}

包含头文件形式，相当于头文件中的声明都加了extern “C”：

extern "C"
{
    #include <demo2.h>
}

其他说明：
(1) 不可以将extern “C” 添加在函数内部。
(2) 如果函数有多个声明，可以都加extern “C”, 也可以只出现在第一次声明中，后面的声明会接受第一个链接指示符的规则。
(3) 除extern “C”, 还有extern “FORTRAN” 等。

3. extern "C"深入剖析

3.1. 不使用extern "C"会发生什么？

C和C++编译器对函数的编译处理是不完全相同的。

C++支持函数重载，因此编译器编译函数的过程中会将函数的参数类型也加到编译后的代码中，即编译后的函数名一般是以原函数名和形参类型来命名的
C语言不支持函数重载，因此编译C语言代码的函数时不会带上函数的参数类型，即为原函数名

在链接阶段，是通过函数名查找函数的，extern "C"作用就是强制其包含的代码按照C语言去编译，即编译出的函数名是原函数名称，否则会出现常见的"undefined reference to …"错误。

接下来，我们以附录A中的源码为例进一步说明。

修改附录A中的demo1.h源码，将extern "C"相关代码注释掉，如下所示。

// File: demo1.h
#ifndef __DEMO1_H__
#define __DEMO1_H__

//#ifdef __cplusplus			// __cplusplus为c++编译器默认定义的宏
//    extern "C" {			// extern "C"告诉编译器此部分代码使用c语言方式进行编译
//#endif
#include "demo2.h"			// 调用c实现的demo2头文件，在extern "C"内，按照c语言方式进行编译
//#ifdef __cplusplus
//    }
//#endif

double sub(double a, float b);	// demo1自有函数，不在extern "C"内，使用c++方式进行编译

#endif

按照2.1.节所述，重新编译生成目标文件demo1.o和demo2.o并查看。可以发现C++编译出来的demo1.o中的add函数名实际上是_Z3addii，其中ii代表两个int类型的参数；而C编译出来的demo2.o中的add函数名就是原本的函数名add。

root@ubuntu:/opt/extern_tmp# gcc -Wall ./demo_c/demo2.c -c -o ./build/demo2.o
root@ubuntu:/opt/extern_tmp# g++ -Wall ./demo_cpp/demo1.cpp -c -o ./build/demo1.o -I./demo_c
root@ubuntu:/opt/extern_tmp# nm -A ./build/demo1.o 
./build/demo1.o:                 U __cxa_atexit
./build/demo1.o:                 U __dso_handle
./build/demo1.o:                 U _GLOBAL_OFFSET_TABLE_
./build/demo1.o:0000000000000113 t _GLOBAL__sub_I_main
./build/demo1.o:0000000000000000 T main
./build/demo1.o:                 U _Z3addii 
./build/demo1.o:00000000000000a4 T _Z3subdf
./build/demo1.o:00000000000000c6 t _Z41__static_initialization_and_destruction_0ii
./build/demo1.o:                 U _ZNSolsEd
./build/demo1.o:                 U _ZNSolsEi
./build/demo1.o:                 U _ZNSt8ios_base4InitC1Ev
./build/demo1.o:                 U _ZNSt8ios_base4InitD1Ev
./build/demo1.o:                 U _ZSt4cout
./build/demo1.o:0000000000000000 r _ZStL19piecewise_construct
./build/demo1.o:0000000000000000 b _ZStL8__ioinit
./build/demo1.o:                 U _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
root@ubuntu:/opt/extern_tmp# 
root@ubuntu:/opt/extern_tmp# nm -A ./build/demo2.o 
./build/demo2.o:0000000000000000 T add
root@ubuntu:/opt/extern_tmp#

按照2.1.节所述，继续进行链接操作，报错如下。demo1.o中编译出来的add函数名称是_Z3addii，且其是U(Undefined)状态，编译器会在demo2.o中寻找_Z3addii，然而demo2.o 中的add函数名是add而不是_Z3addii，故没有找到而报错。如果使用extern “C”，则demo1.o中的_Z3addii会变成add，即强制按照C语言方式编译该函数，也就能链接成功，感兴趣的读者可以自行验证。

root@ubuntu:/opt/extern_tmp# g++ -Wall ./build/*.o -o ./build/demo
/usr/bin/ld: ./build/demo1.o: in function `main':
demo1.cpp:(.text+0x35): undefined reference to `add(int, int)'
collect2: error: ld returned 1 exit status
root@ubuntu:/opt/extern_tmp#

3.2. extern "C"的双重含义

extern "C"限定的函数或变量是extern类型的
(1) extern是C/C++语言中表明函数和全局变量的作用范围的关键字，该关键字告诉编译器，其申明的函数和变量可以在本模块或其他模块中使用；需要注意的是，语句extern int a仅仅是一个变量的声明，并不是在定义变量a，也并未为a分配空间，变量a在所有模块中作为一种全局变量只能被定义一次，否则会出错。
(2) 通常来说，在模块的头文件中对本模块提供给其他模块引用的函数和全局变量以关键字extern声明。例如，如果模块B要引用模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但并不会报错，它会在链接阶段从模块A编译生成的目标代码中找到该函数。
(3) extern对应的关键字是static，static表明变量或者函数只能在本模块中使用。因此，被static修饰的变量或者函数不可能被extern "C"修饰。
extern "C"修饰的变量和函数是按照C语言方式进行编译和链接的
如上文所述，C++支持函数重载，而C语言不支持，因此函数被C++编译后在符号表中的名字是与C语言不同的；C++编译后的函数需要加上参数的类型才能唯一标定重载后的函数，而加上extern "C"后，是为了向编译器指明这段代码按照C语言的方式进行编译。

4. 参考文献

附录A C++调用C源码实例

A.1 源码结构

root@ubuntu:/opt/extern_tmp# tree ./
./
├── build
│   ├── demo				// 最终生成的可执行文件
│   ├── demo1.o				// gcc编译的c源码目标文件
│   └── demo2.o				// g++编译的c++源码目标文件
├── demo_c					// c源码
│   ├── demo2.c
│   └── demo2.h
└── demo_cpp				// c++源码，调用c源码
    ├── demo1.cpp
    └── demo1.h
3 directories, 7 files
root@ubuntu:/opt/extern_tmp#

A.2 源码实现

demo1.cpp源码

// File: demo1.cpp
#include <iostream>
using namespace std;
#include "demo1.h"

int main(int argc, char *argv[])
{
    cout << "a+b=" << add(1,1) << "\n";		// 调用c实现的demo2中的函数add
    cout << "a-b=" << sub(1,1) << "\n";		// 调用c++实现的demo1自有函数sub
    return 0;
}

double sub(double a, float b)
{
    return (a-b);
}

demo1.h源码

// File: demo1.h
#ifndef __DEMO1_H__
#define __DEMO1_H__

#ifdef __cplusplus			// __cplusplus为c++编译器默认定义的宏
    extern "C" {			// extern "C"告诉编译器此部分代码使用c语言方式进行编译
#endif
#include "demo2.h"			// 调用c实现的demo2头文件，在extern "C"内，按照c语言方式进行编译
#ifdef __cplusplus
    }
#endif

double sub(double a, float b);	// demo1自有函数，不在extern "C"内，使用c++方式进行编译

#endif

demo2.c源码

// File: demo2.c
#include "demo2.h"
int add(int a, int b)
{
    return (a+b);
}

demo2.h源码

// File: demo2.h
#ifndef __DEMO2_H__
#define __DEMO2_H__

int add(int a, int b);

#endif

附录B C调用C++源码实例

B.1 源码结构

root@ubuntu:/opt/extern_tmp1# tree ./
./
├── build
│   ├── demo					// gcc编译demo1.c和libdemo2_mid.so、libdemo2.so生成的可执行文件
│   ├── libdemo2_mid.so			// g++编译libdemo2.so和mid.cpp生成的中间接口库
│   └── libdemo2.so				// g++编译c++源码生成的动态库
├── demo_c
│   ├── demo1.c					// c源码，通过中间接口库调用c++源码
│   └── mid.cpp					// 中间c++源码，用于对c++库进行二次封装，生成中间接口库
└── demo_cpp					// c++源码，生成动态库
    ├── demo2.cpp
    └── demo2.h
3 directories, 7 files
root@ubuntu:/opt/extern_tmp1#

B.2 源码实现

demo1.cpp源码

// File: demo1.c
#include <stdio.h>

int m_add(int a, int b);

int main(int argc, char *argv[])
{
    printf("a+b=%d\n", m_add(1,1));		// 调用中间接口库中的m_add函数
    return 0;
}

mid.cpp源码

// File: mid.cpp
#include <iostream>
#include "demo2.h"				// 包含原c++实现的add函数声明，不在extern "C"内，仍以c++方式编译

#ifdef __cplusplus
    extern "C" {				// extern "C"告诉编译器此部分代码使用c语言方式进行编译
#endif

int m_add(int a, int b)			// 二次封装成m_add函数，在extern "C"内，将以c语言方式编译，便可以被c源码调用
{
    return add(a, b);
}

#ifdef __cplusplus
    }
#endif

demo2.cpp源码

// File: demo2.cpp
#include <iostream>

int add(int a, int b)
{
    std::cout << "c++ implements a+b" << "\n";
    return (a+b);
}

demo2.cpp源码

// File: demo2.h
#ifndef __DEMO2_H__
#define __DEMO2_H__

int add(int a, int b);

#endif

回笼觉觉父

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录