NDK开发中C与C++互相调用处理

最新推荐文章于 2023-06-12 17:42:10 发布
最新推荐文章于 2023-06-12 17:42:10 发布
阅读量406 收藏
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ffjffjffjffjffj/article/details/103566886
版权

    在NDK开发中难免会遇到C与C++混合编程，比如C调用C++写的so库或者C++调用C的函数库，如果不做特别处理，就会出现编译通过但链接时找不到函数或者压根就编译不通过的情况。

       为什么会出现这种情况？

有两个原因：

1.C++比C出现的晚，在C++里出现了很多新的特性，比如类、命名空间等，是C不支持的，因为C不能向下兼容，比如在C程序中直接使用new关键字生成一个对象是不支持的。

2.C++支持函数重载，C不支持函数重载，在编译后，C++的函数名会被修改，而C的函数名基本上不变，由于两者在编译后函数名的命名策略不同，所以在不处理的情况下，C调用C++的函数或者C++调用C函数，都会在链接阶段报找不到函数的错误。

如何解决函数名找不到的问题

          使用 extern "C" { }

          作用：通知C++编译器将extern  "C"所包含的代码按照C的方式编译和链接

           注意：extern "C" 是在C++里增加的，C里面不能识别

有两种调用情况：

1.C++调用C函数

    a.如果C函数在.h中声明，我们直接用extern "C"包含函数，比如这样:

/* file myCHead.h */
#ifndef MYCHEAD_H
#define MYCHEAD_H

extern "C" {

  int funC();

}

#endif //MYCHEAD_H

那么C++调用该函数时，只需要引入myCHead.h即可：

/* file myCppSource.cpp */

#include "stdio.h"
#include "myCHead.h"

int main()
{
    printf("funC:%d", funC());
    return 0;
}

这时候cpp里include进来的myCHead.h，因为funC()函数有 extern "C"包含，那么C++编译器不会对funC()函数名采用C++策略处理，而采用C编译器策略，而.c的代码NDK会默认采用C编译器进行编译，正因为函数的调用处与实现处都采用了相同的命名策略，故最后能正确链接。

接下来实现.c的程序：

/* file myCSource.c */
#include "myCHead.h"

int funC()
{
    return 100;
}

这时候myCSource.c里也include了myCHead.h，那么问题出现了，如果我们把myCSource.c展开(因为 #include 的本质就是把对应的文件直接拷贝到这一行里面 )：

/* file myCSource.c */
extern "C" {

  int funC();

}

int funC()
{
    return 100;
}

前面说过，extern "C"是C++里加入的，在C里面并不识别，所以这里在编译时就会报错

解决方案：使用 #ifdef __cplusplus，因为“__cplusplus”是C++中的自定义宏，C里面没有，所以当.h可能被C与C++同时使用时，又使用了extern "C"，这时使用 #ifdef __cplusplus 来规定，如果是C的代码，就不需要使用extern "C"，所以正确的 myCHead.h为：

/* file myCHead.h */
#ifndef MYCHEAD_H
#define MYCHEAD_H

#ifdef __cplusplus
extern "C" {
#endif

  int funC();

#ifdef __cplusplus
}
#endif

#endif //MYCHEAD_H

在这里要明白，#ifdef __cplusplus主要为了防止extern "C"被C程序使用，假设头文件只被C++使用，那就不需要用 #ifdef __cplusplus。

b.如果没有 myCHead.h头文件，如何做

   很简单，前面说了 #include 的本质就是把对应的文件直接拷贝到这一行里面，所以直接在C++程序中声明一下 funC()函数：

/* file myCppSource.cpp */

#include "stdio.h"
extern "C" int funC();

int main()
{
    printf("funC:%d", funC());
    return 0;
}

对编译器来说，其实质与引用头文件一样，还省了#ifdef __cplusplus

2.C调用C++程序

       C调用C++程序比C++调用C要复杂一些，因为除了同样会有编译后函数命令策略不同的问题，还会有C不能向下兼容C++新特征的问题

a.C调用C++的全局函数(不在类里面)

   此时C能直接调用C++的函数，但是如果不处理，同样会在链接时报找不到函数名的错误，所以还是要依赖extern "C"

    因为extern "C" 是给C++使用的，目的就是告诉C++编译器，其函数命名规则采用C的方式，这样C调用了C++函数，在链接时就能找得到

    所以C++的头文件可以这样（比如C++中增加一个funCPP()函数提供给C用）：

C++头文件：

/* file myCPPHead.h */
#ifndef MYCPPHEAD_H
#define MYCPPHEAD_H

#ifdef __cplusplus
extern "C" {
#endif

int funCPP();

#ifdef __cplusplus
}
#endif

#endif //MYCPPHEAD_H

C++源程序：

/* file myCppSource.cpp */

#include "stdio.h"
#include "myCppHead.h"
extern "C" int funC();

int main()
{
    printf("funC:%d", funC());
    return 0;
}

int funCPP(){
    return 200;
}

注意：#include "myCppHead.h"一定不能少，因为这句话就是告诉C++编译器 函数funCPP()采用C的方式编译，否则C程序调用funCPP()会出错。

C增加调用C++函数：

/* file myCSource.c */
#include "myCHead.h"
#include "myCppHead.h"

int funC()
{
    return 100;
}

int main() {
    printf("funCPP:%d", funCPP());
    return 0;
}

正因为myCppHead.h被C引用了，所以myCppHead.h里的 extern "C" ， 外面要用#ifdef __clusplus包一下。

可以思考一下，如果C++没有提供的.h，C如何使用其中的全局函数？

      很显然，可以在myCppSource.cpp源程序中，将提供给C调用的函数用  extern "C"进行修饰，C程序里用 extern int funCPP(); 声明一下即可。

再思考一下，如果C++里面有重载函数，如何被C调用？

比如 myCppSource.cpp变成：

/* file myCppSource.cpp */

#include "stdio.h"
#include "myCppSource.h"
extern "C" int funC();

int main()
{
    printf("funC:%d", funC());
    return 0;
}

int funCPP(){
    return 200;
}

int funCPP(int value){
    return value;
}

然后C需要调用funCPP(int value)怎么办？

解决方法就是用另一个函数包装一下，然后将该函数提供给C调用：

改造后的myCppHead.h:

/* file myCPPHead.h */
#ifndef MYCPPHEAD_H
#define MYCPPHEAD_H

int funCPP();
int funCPP(int value);

#ifdef __cplusplus
extern "C" {
#endif

int funCPP1();
int funCPP2(int value);

#ifdef __cplusplus
}
#endif

#endif //MYCPPHEAD_H

改造后的myCppSource.cpp:

/* file myCppSource.cpp */

#include "stdio.h"
#include "myCppHead.h"
extern "C" int funC();

int main()
{
    printf("funC:%d", funC());
    return 0;
}

int funCPP(){
    return 200;
}

int funCPP(int value){
    return value;
}

int funCPP1() {
    return funCPP();
}

int funCPP2(int value) {
    return funCPP(value);
}

C调用funCPP(int value)，改造后的myCSource.c:

/* file myCSource.c */
#include "myCHead.h"
#include "myCppHead.h"

int funC()
{
    return 100;
}

int main() {
    //printf("funCPP:%d", funCPP());
    printf("funCPP(int):%d", funCPP2(300));
    return 0;
}

 

最后再思考一下，如果C++提供的库，你没办法去修改头文件与源文件，向其中加上 extern "C"，那么C如何调用其提供的函数？

     也有解决办法：也是包装，可以增加一个新的cpp，里面使用包装函数调用C++库函数，然后将包装函数用 extern "C"修饰后，提供给C使用。

b.C调用C++的类函数

        由于C不能向下兼容CPP的一些新特征，比如面向对象特征，所以C里不可能直接去new一个对象，再使用对象提供函数。我们前面有讲使用包装的方式间接调用重载函数的解决办法，正好在这里也可以用包装的方式。

C++里增加一个类：

/* file myCPPHead.h */
#ifndef MYCPPHEAD_H
#define MYCPPHEAD_H

int funCPP();
int funCPP(int value);

class MyClass {
    int funCPP();
};

#ifdef __cplusplus
extern "C" {
#endif

int funCPP1();
int funCPP2(int value);

#ifdef __cplusplus
}
#endif

#endif //MYCPPHEAD_H
/* file myCppSource.cpp */

#include "stdio.h"
#include "myCppHead.h"
extern "C" int funC();

int main()
{
    printf("funC:%d", funC());
    return 0;
}

int funCPP(){
    return 200;
}

int funCPP(int value){
    return value;
}

int funCPP1() {
    return funCPP();
}

int funCPP2(int value) {
    return funCPP(value);
}

int MyClass::funCPP(){
    return 400;
}

请思考一下，上面这样改造后，可行否？

显然是不行的， 因为 myCSource.c里有一句

#include "myCppHead.h"

而myCppHead.h里有class的声明，编译时myCSource.c肯定会报错，如何解决？

两个办法，1、将MyClass的声明放到.cpp中；2、增加一个新的cpp来包装

如果采用第一种方法，将MyClass的声明放到.cpp中，再加上包装函数，则改造后的程序如下：

/* file myCPPHead.h */
#ifndef MYCPPHEAD_H
#define MYCPPHEAD_H

int funCPP();
int funCPP(int value);

#ifdef __cplusplus
extern "C" {
#endif

int funCPP1();
int funCPP2(int value);

//以下供C调用对象的成员函数
void* createObject();
int funCPP3(void* object);

#ifdef __cplusplus
}
#endif

#endif //MYCPPHEAD_H
/* file myCppSource.cpp */

#include "stdio.h"
#include "myCppHead.h"
extern "C" int funC();

class MyClass {
    int funCPP();
};

int main()
{
    printf("funC:%d", funC());
    return 0;
}

int funCPP(){
    return 200;
}

int funCPP(int value){
    return value;
}

int funCPP1() {
    return funCPP();
}

int funCPP2(int value) {
    return funCPP(value);
}

void* createObject(){
    return new MyClass();
}

int funCPP3(void* object){
    MyClass* myClassObj = (MyClass*)object;

    return myClassObj->funCPP();
}

int MyClass::funCPP(){
    return 400;
}

myCSource.c里调用，改造后：

/* file myCSource.c */
#include "myCHead.h"
#include "myCppHead.h"

int funC()
{
    return 100;
}

int main() {
    //printf("funCPP:%d", funCPP());
    
    //printf("funCPP(int):%d", funCPP2(300));

    void *cppObj = createObject();
    printf("class funCPP:%d", funCPP3(cppObj)); 
    
    return 0;
}

 

如果不许直接修改myCppHead.h与myCppSource.cpp，向里面增加包装函数，则采用

另一种方式：增加一个.h与.cpp或者只增加.cpp来进行包装：

myCppHead.h与myCppSource.cpp恢复成之前：

/* file myCPPHead.h */
#ifndef MYCPPHEAD_H
#define MYCPPHEAD_H

int funCPP();
int funCPP(int value);

#ifdef __cplusplus
extern "C" {
#endif

int funCPP1();
int funCPP2(int value);

#ifdef __cplusplus
}
#endif

#endif //MYCPPHEAD_H
/* file myCppSource.cpp */

#include "stdio.h"
#include "myCppHead.h"
extern "C" int funC();

class MyClass {
    int funCPP();
};

int main()
{
    printf("funC:%d", funC());
    return 0;
}

int funCPP(){
    return 200;
}

int funCPP(int value){
    return value;
}

int funCPP1() {
    return funCPP();
}

int funCPP2(int value) {
    return funCPP(value);
}

int MyClass::funCPP(){
    return 400;
}

新增的.h与.cpp：

/* file myWrapperCppHead.h */

#ifndef MYWRAPPERCPPHEAD_H
#define MYWRAPPERCPPHEAD_H

#ifdef __cplusplus
extern "C" {
#endif

void* createObjectFromWrapper();
int funCPP3FromWrapper(void* object);

#ifdef __cplusplus
}
#endif

#endif //MYWRAPPERCPPHEAD_H
/* file myWrapperCppSource.cpp */
#include "myWrapperCppHead.h"
#include "myCppHead.h"

void* createObjectFromWrapper(){
    return new MyClass();
}

int funCPP3FromWrapper(void* object){
    MyClass* myClassObj = (MyClass*)object;

    return myClassObj->funCPP();
}

C调用成员函数 新的方式：

/* file myCSource.c */
#include "myCHead.h"
#include "myWrapperCppHead.h"

int funC()
{
    return 100;
}

int main() {
    //printf("funCPP:%d", funCPP());

    //printf("funCPP(int):%d", funCPP2(300));

    void *cppObj = createObjectFromWrapper();
    printf("user wrapper class funCPP:%d", funCPP3FromWrapper(cppObj));

    return 0;
}

 

最后总结一下：

1.C++中增加了extern "C" 关键字来告诉C++编译器，函数命名采用C的方式

2.extern "C" 只能在C++中使用，了为防止头文件中存在extern "C" ，而该头文件可能会被C源程序include，可以采用 #ifdef __cplusplus 对 extern "C" 进行限制

3.C++能调用C函数的关键就是在C++里需要声明C函数，且采用 extern "C" 修饰

4.C能调用C++非成员函数的关键就是 在C++中，C++函数需要使用 extern "C" 修饰

5.如果C++头文件或源文件无法修改，使其加上 extern "C" 修饰时，可以增加一个新的包装cpp，包装cpp里采用包装函数直接调用目标函数，包装函数使用 extern "C" 修饰后供C使用

6.C调用C++成员函数，需要使用包装函数



作者：会上网的井底之蛙
链接：https://www.jianshu.com/p/49859d267567
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

oj_fang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++和Java互相调用实例
09-26
C++和Java互相调用代码实例总结。项目工程实例使用AS创建，下载后可直接编译安装运行
Android NDK中将图像列表返回给Java调用层处理方法
11-10
在Android开发图像处理APP中，经常会将Bitmap传到JNI中，使用OpenCV等工具处理后直接将Bitmap返回到Java调用层作输出显示，因此该源码提供了解决方案。 参考地址：https://blog.csdn.net/qq_39312146/article/details/127781165
NDK中JAVA和C互相调用
04-07
JAVA调用C, C调用JAVA创建一个按钮 这个按钮点击后，又调用一个C函数 改编自NDK例子
Android NDK开发的环境搭建与简单示例
01-04
一、NDK与JNI简介 NDK全称为native development kit本地语言（C&C++）开发包。而对应的是经常接触的Android-SDK，（software development kit）软件开发包（只支持java语言开发）。 简单来说利用NDK，可以开发纯C&C++的代码，然后编译成库，让利用Android-SDK开发的Java程序调用。NDK开发的可以称之为底层开发或者jni（java native interface）层开发，SDK开发可以称为上层开发。 Android开发中使用NDK的原因： 1、众所周知，利用SDK编写的代码，生成的APK，很容易就可以反编译了，安全
使用 Android NDK 的交叉编译工具链移植 C/C++ 项目到安卓平台
xyjikl
10-19 2162
什么是 NDK？ Android NDK 是一套可以让开发者在安卓应用开发中使用 C/C++ 实现特定模块的工具集，不是所有应用都需要用到，但是正确地使用可以有效提高应用运行效率和安全性。 为什么要在安卓开发中使用 NDK？ 游戏引擎使用 Native 的 C/C++ 库，便于跨平台移植，开发游戏应用，使用NDK可以直接调用这些库通用应用开发中，像加密、解密以及其他一些核心算法等
Android ndk c c 混合编程,Android SDK/NDK混编开发环境变量设置
weixin_39636226的博客
05-26 75
1、Windows环境变量设置：CYGWIN=nodosfilewarningCYGWIN_PATH=C:/cygwin/binNDK_ROOT=C:/AndroidSDK/android-ndk-r5b2、Eclipse下项目属性设置：include路径：${NDK_ROOT}/toolchains/arm-eabi-4.4.0/prebuilt/windows/lib/gcc/arm-eabi...
Android NDK开发: 通过C/C++调用第三方so库
热门推荐
zuguorui的专栏
07-21 1万+
上一篇打包so库及jar包的博客我讲了如何将自己的代码打包成so库，并且配合jar包供他人调用。但那种方式仅适合对方从java层调用，如果算法是比较核心的，而又为了效率必须从native来调用，那种方式就不合适了。本篇讲如何打包我们自己的核心代码供他人在native调用，如果对方愿意，也可以自己封装然后从java来调用，灵活性更高。并且在调试的时候更加方便。这种方式是更接近纯C/C++工程的集成...
ARM（Android NDK）混编C/C++汇编优化
feelinghappy的专栏
02-12 1164
在进行Android开发时，一般考虑加速某些算法处理速率时，需要使用NDK进行开发， 为了进一步加速程序执行速率，还可以进行汇编级别的优化。 比如采用 NEON 技术进行代码的优化，以实现模块处理效率的成倍增长。 在C/C++中使用内联汇编的用法如下： asm( "ADD R0,R0,#1 \n\t"       // 使R0寄存器值增加1，后面加换行符和制表符是为了汇编代码的美观，其中有...
android-19 ndk,Android NDK开发之旅19--C++--基本概念、基本常识
weixin_30340109的博客
05-27 228
前言——C与C++的关系C++可以与C代码进行混编，C++里面可以写C，但是反过来不可以。C++是面向对象编程语言、C是面向过程的编程。C++对C的一个增强。C++有class、引用的概念，堆内存的分配释放除了C语言的malloc、free，还有new、delete关键字。C++的命名空间基本概念命名空间，也叫名字空间，类似于Java中包(归类)。当项目比较大的时候，用于区分不同人写的代码、不同库...
懒人模式：在现有的AS项目上添加C++（NDK）代码
我点灯的博客
01-12 871
在网上找了很多构建NDK项目的方法，一个个都太繁琐了，这命令那命令、这配置那配置的，完全不适合我这种手残党。于是我在这里整理了一份秋~简单的“搭建NDK环境的方法”。（ps：如果你是想在现有项目中集成NDK，可以跳到后面看） 如果是一个新的项目 第一步：那么可以在Android Studio启动时选择新建项目（Start a new Android Studio Project） 第二步： ...
NDK中C++使用POSIX线程库调用java
06-08
NDK中C++使用POSIX线程库调用java的一个Demo，NDK多线程实现生产者消费者实例。想学习一下的同学，快快下载吧！
NDK开发C++基础
liuwushuang233的博客
03-16 616
const 是防止修改值，而&是性能的提高，如果没有&，执行对象+对象的时候，调用到positon operator + (const positon pos1){会构建新的副本，后传入的pos2和 (const positon pos1)里的pos1会是两个不同的对象，加上&则不会构建新的副本，不会构造新的副本，&是给pos2所指向的内存空间取一个新的别名，但是没有产生新的副本。真实开发中，静态函数，友元函数，普通函数，构造函数，析构函数，拷贝构造函数 区别。传入的两个子类，输出的都是父类的。
NDK在Linux下载配置以及C、C++编译配置（交叉编译）
yangbinbingA的博客
06-08 2756
NDK在Linux下载配置以及C、C++编译配置（交叉编译） 前言： 我们搭建好Ubutu虚拟机之后，通过xShell远程登录Ubutu上SSH服务器，在xShell上可以进行相关的编译操作了。但是我们在xShell上gcc、g++编译的可执行文件只能在Linux上执行，但是我们需要编译出来的东西可以在Android端使用，这就需要进行交叉编译，在Ubutu上编译出Android可执行的文件以及动态库。在编译之前，需要将NDK下载安装完成，并且成功配置环境变量，才能进行下面编译。废话不多说了，开始介绍了(备
NDK开发C/C++基础
believeinbelieve的博客
01-12 825
学习NDK开发需要掌握一些C/C++的基础知识
NDK学习之路-C++线程篇
weixin_39971470的博客
08-28 139
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 pthread 线程学习 。 一、线程的基本使用 1.如何引入外部库 在cmakeList中 第一步：引入头文件 # TODO 第一步：引入线程库的所有头文件 include_directories("D:/NDK/CoursewareCreate/ndk_06/pthreads-w32...
NDK编译c++代码
最新发布
qq_25670983的博客
06-12 890
对于 Clang/LLVM 工具链，你可以通过安装 Clang 来获取 C++ 编译器。在该目录下，创建你的 C++ 代码文件（例如，MyDLL.cpp）。在你选择的位置创建一个新的目录来作为你的 NDK 项目的根目录。例如，可以在你的计算机上创建一个名为 “NDK” 的目录。如果你希望在本地使用 NDK 编译 C++ 代码，你需要安装 g++ 或 Clang/LLVM 等 C++ 编译器工具链。无论你选择使用哪种工具链，确保你的环境中安装了适当的 C++ 编译器，以便在本地编译和构建 NDK 项目。
Android Studio 进行NDK开发，实现JNI，以及编写C++与Java交互（Java调用本地函数）并编译出本地so动态库
UrasakiNakajima的博客
05-26 5879
NDK集成了交叉编译器（交叉编译器需要UNIX或LINUX系统环境），并提供了相应的mk文件隔离CPU、平台、ABI等差异，开发人员只需要简单修改mk文件（指出“哪些文件需要编译”、“编译特性要求”等），就可以创建出so。就会生成两个文件这几个so文件，如下图一，然后就能正常获取到C++文件（也就是cpp文件）中的数据了，还可以把so动态库提供给第三方使用，具体方式详见。在android的JNI中，要先将相应的C/C++打包成so库，然后导入到lib文件夹中供java调用。（5）安卓中的so文件是什么？
使用NDK编译C++代码
log_zhan的博客
12-24 7435
这里写自定义目录标题一、使用NDK编译C++代码1.1概述1.2 NDK下载与环境配置1.3 NDK代码编译1.3.1 编译目录建立1.3.2 mk文件配置1.3.2 NDK编译1.4 总结 一、使用NDK编译C++代码 1.1概述 最近需要把PC端实现的算法移植到Unity3d, 但是发现从C++算法移植到C#代码性能损失的太多了。在C++实现下，是可以做到实时的，但是移植到C#上面几乎卡的不能...
NDK学习之路之 c++ 知识归纳
Androidtalent的博客
08-25 320
1.c++ 引用 其实就是四驱模型的拷贝，引用其实是地址赋值，可以看成同一块内存的另外一个变量 以两个变量值交换为例 #include<stdio.h> void swap(int &number1, int &number2) { // &number 此处相当于同一块内存 取了另一个别名 int temp = number1; number1 = nu...
Android studio中NDK开发
06-01
Android Studio 中使用 NDK 进行开发需要进行以下步骤： 1. 安装 CMake 和 NDK 在 Android Studio 中，可以通过 SDK Manager 安装 CMake 和 NDK。在 SDK Manager 中选择 "SDK Tools" 标签页，然后勾选 "CMake" 和 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值