c/c++混合编程--整理

最新推荐文章于 2024-06-25 20:58:15 发布

Asome

最新推荐文章于 2024-06-25 20:58:15 发布

阅读量917

点赞数

分类专栏： C/C++ 文章标签： cc++混合编程 c c++

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

40 篇文章 1 订阅

订阅专栏

一、混合编程基础

C与C++混合编程

C++ 是在 C 语言的基础上发展起来的。在某种程度上，我们可将 C++ 看做 C 的一种扩展。在本质上，二者的数据类型和函数调用惯例都是一致的，因此 C 与 C++ 混合编译也是很自然的事情。

二者的区别仅在于编译后函数的名字不同──C 简单地使用函数名而不考虑参数的个数或类型，而 C++ 编译后的函数名则总是将参数类型列表作为其一部分。尽管如此，C++ 提供了特殊的机制来声明 C 函数，这意味着一个 C++ 程序可以直接声明和调用 C 函数。

C++调用C函数

下面是 C++ 程序调用 C 函数 csayhello() 的一个例子。由于该函数在 C++ 程序内声明时使用了 extern "C"，故调用可以直接进行：

/* cpp2c.cpp */
#include <iostream>
extern "C" void csayhello(char *str);
int main(int argc,char *argv[])
{
    csayhello("Hello from cpp to c");
    return(0);
}

C 函数不需任何特殊处理，其代码如下：

/* csayhello.c */
#include <stdio.h>
void csayhello(char *str)
{
    printf("%s\n",str);
}

下面三条命令编译以上两个文件并将二者链接为一个可执行文件。由于 gcc 和 g++ 的灵活性使得存在很多方法来完成该任务，但这三条命令或许是最常用的：

$ g++ -c cpp2c.cpp -o cpp2c.o
$ gcc -c csayhello.c -o csayhello.o
$ gcc cpp2c.o csayhello.o -lstdc++ -o cpp2c

注意到，在最后链接的时候指定 C++ 标准库是必须的，这是因为我们用的是 gcc 而不是 g++ 调用的链接器。如果使用的是 g++ 的话，C++ 标准库默认会被链接。

最普遍的做法是，将函数声明放到头文件中，然后将所有内容包含在 extern "C" 声明块内。文件内容像下面所示：

extern "C" {
    int mlimitav(int lowend, int highend);
    void updatedesc(char *newdesc);
    double getpct(char *name);
};

C调用C++函数

要使 C 程序能够调用 C++ 中函数的话，C++ 提供一个符合 C 调用惯例的函数是必须的。下面的例子演示了在 C++ 内创建 C 函数的语法：

/* cppsayhello.cpp */
#include <iostream>
extern "C" void cppsayhello(char *str);
void cppsayhello(char *str)
{
    std::cout << str << "\n";
}

尽管函数 cppsayhello() 通过 extern "C" 声明为 C 函数，事实上它是 C++ 源代码的一部分，这意味着函数体内是真正的 C++ 代码。在函数内你可以自由地创建和析构对象。如果你要在 cppsayhello() 内调用 C 函数的话，将其声明为 extern "C" 是必须的。否则，编译器会将作为一个 C++ 函数并相应地更改函数名。

下面是调用 C++ 函数 cppsayhello() 的 C 程序：

/* c2cpp.c */
int main(int argc,char *argv[])
{
    cppsayhello("Hello from C to C++");
    return(0);
}

下面的命令编译并链接生成c2cpp：

$ g++ -c cppsayhello.cpp -o cppsayhello.o
$ gcc -c c2cpp.c -o c2cpp.o
$ gcc cppsayhello.o c2cpp.o -lstdc++ -o c2cpp

二、混合编程之cpp函数

将 C++ 函数声明为``extern "C"''（在你的 C++ 代码里做这个声明），然后调用它（在你的 C 或者 C++ 代码里调用）。例如： // C++ code:

extern "C" void f(int);

void f(int i)

{

// ...

}

然后，你可以这样使用 f（）： /* C code: */

void f(int);

void cc(int i)

{

f(i);

/* ... */

}

当然，这招只适用于非成员函数。如果你想要在 C 里调用成员函数（包括虚函数），则需要提供一个简单的包装（wrapper）。例如： // C++ code:

class C

{

// ...

virtual double f(int);

};

extern "C" double call_C_f(C* p, int i) // wrapper function

{

return p->f(i);

}

然后，你就可以这样调用 C：：f（）： /* C code: */

double call_C_f(struct C* p, int i);

void ccc(struct C* p, int i)

{

double d = call_C_f(p,i);

/* ... */

}

如果你想在 C 里调用重载函数，则必须提供不同名字的包装，这样才能被 C 代码调用。例如： // C++ code:

void f(int);

void f(double);

extern "C" void f_i(int i) { f(i); }

extern "C" void f_d(double d) { f(d); }

然后，你可以这样使用每个重载的 f（）： /* C code: */

void f_i(int);

void f_d(double);

void cccc(int i,double d)

{

f_i(i);

f_d(d);

/* ... */

}
注意，这些技巧也适用于在 C 里调用 C++ 类库，即使你不能（或者不想）修改 C++ 头文件。

///

现在将我的想法给总结一下：
首先使用extern "C" 出错的原因在于两个文件都是用g++编译的，所以都是c++组织格式，使用extern "C"是画蛇添足。要不两个文件都用加，要不两个都不加。
另外最后一步直接使用g++ -o main_test a.c -L. -lmain_test，就是使用g++对a.c 进行编译和链接，extern "C"是为了让c和c++格式的.o文件能够进行链接，所以应该将这一步进行分拆，先用c编译器编译c文件，然后让链接器使用c格式进行链接所以命令应该变为cc -o a.c和g++ -o main_test a.o -L. -lmain_test
shornmao给出的标准做法就可以涵盖上面不同的方法不管是用c编译器还是c++编译器都可以正确处理。如果都是用c++编译器两个文件就不需要extern "C",
就按照c++格式链接。如果c文件使用c编译器 c++文件用c++编译，这样有了extern"C"就可以让链接器可以按照C的方法进行链接c++的.o文件和c的.o文件。

c调用C++的函数.目前的实现基本只有一类方法,即通过处理被调用的C++文件.

文中给出的仍然是完整的,具体的,但又最基本最简单的实现,至于理论性的东西在网上很容易搜索的到.这里是针对调用C++的成员函数的实现.

aa.h

class AA {
    int i;
    public:
        int ThisIsTest(int a, int b);
        float ThisIsTest(float a, float b);
};

extern "C" int ThisIsTest_C(void* s, int a,int b);
extern "C" float PolymorphicTest_C(void* s,float a, float b);

aa.cpp:

#include "aa.h"

int AA::ThisIsTest(int a, int b){
return (a + b);
}

float AA::PolymorphicTest(float a, float b){
return (a+b);
}

int ThisIsTest_C(void* s, int a,int b){
AA* p = (AA*)s;
return p->ThisIsTest(a,b);
}

float PolymorphicTest_C(void* s,float a, float b){
AA* p = (AA*)s;
return p->ThisIsTest(a,b);
}

a.h:

#ifndef __A_H
#define __A_H

int bar(void* s,int a, int b);
int bar_float(void* s,float a, float b);

#endif

a.c

#include <stdio.h>
#include "a.h"

extern int ThisIsTest_C(void* s, int a,int b);
extern float PolymorphicTest_C(void* s,float a, float b);

int bar(void* s,int a, int b) {
printf("result=%d/n", ThisIsTest_C(s,a, b));
return 0;
}

int bar_float(void* s,float a, float b) {
printf("result=%f/n", PolymorphicTest_C(s,a, b));
return 0;
}

main.c:

#include "a.h"

struct S {
int i;
};

struct S s;

int main(int argc, char **argv){
int a = 1;
int b = 2;
float c = 1.5;
float d = 1.4;
bar((void*)&s,a, b);
bar_float((void*)&s,c,d);
return(0);
}

Makefile:

all:
    gcc -Wall -c a.c -o a.o
    gcc -Wall -c aa.cpp -o aa.o
    gcc -Wall -c main.c -o main.o
    g++ -o test *.o

因为C++兼容C,所以C++也有外部函数,C调用C++外部函数很简单.

调用成员函数时,我们只有函数int ThisIsTest(int a, int b)和float ThisIsTest(float a, float b)

extern "C" int ThisIsTest_C(void* s, int a,int b)和extern "C" float PolymorphicTest_C(void* s,float a, float b)是为了调用
上面函数而不得不封装的.

如果类AA有外部函数int function(int a,int b),则我们只需要在C++头文件此函数名前加上extern "C"即可.调用方法一样.这种情况下,我们不需要定义跟AA类相同的struct S.

总结如下:
被调用C++外部函数要使用extern "C"声明,或封装成员函数为外部函数后加extern "C"声明.
多个重载函数封装外部函数函数名必须不同.

被调用的函数参数列表中不能使用类和引用及其他C代码没办法处理的东西.
如果被调用函数所在类有全局变量或静态变量等,我们就必须构造相应的C++类而非C结构体,这时,main()函数要用C++编译器来编译.

如果非要在C中实现main函数,那可以在C++中定义main_c函数

///

〈一〉如何实现C中调用C++
链接库头文件:
//head.h
class A
{
          public:
          A();
          virtual ~A();
          int gt();
          int pt();
private:
          int s;
};
.cpp
//firstso.cpp
#include
#include "head.h"

A::A(){}
A::~A(){}
int A::gt()
{
s=10;
}
int A::pt()
{
std::cout<<s;
}
编译命令如下:
g++ -shared -o libmy.so firstso.cpp
这时候生成libmy.so文件,将其拷贝到系统库里面:/usr/lib/
进行二次封装:
.cpp
//secso.cpp
#include
#include "head.h"
extern "C"
{

int f();

int f()
{
A a;
a.gt();
a.pt();
return 0;
}

}
编译命令:
gcc -shared -o sec.so secso.cpp -L. -lmy
这时候生成第二个.so文件,此时库从一个类变成了一个c的接口.
拷贝到/usr/lib
下面开始调用:
//test.c
#include "stdio.h"
#include "dlfcn.h"

#define SOFILE "sec.so"
int (*f)();
int main()
{
void *dp;
dp=dlopen(SOFILE,RTLD_LAZY);
f=dlsym(dp,"f");
f();
return 0;
}
编译命令如下:
gcc -rdynamic -s -o myapp test.c
运行Z$./myapp
10
$

有两个地方要改一下，最后的编译语句应该是：
gcc -rdynamic -s -o -ldl myapp test.c
还有就是test.c最后应该加上：
dlclose(dp);
否则会CoreDump。
实际上他是把类的方法变成了一个可以外部调用的C函数，用extern C。

二〉C++程序如何调用C语言写的库,如a.lib等，有对应的库头文件a.h。假设a.h中定义了函数:

int WhyCoding(int a, float b);

做法是,

/* cpp_a.h */

extern "C" {

#include "a.h"

}

或

/* cpp_a.h */

extern "C" {

int WhyCoding(int a, float b); /* 重定义所有的C函数 */