c语言和c++的相互调用_c语言调用c++

本文收录于微信公众号「 LinuxOK 」，ID为：Linux_ok，关注公众号第一时间获取更多技术学习文章。

在实际项目开发中，c和c++代码的相互调用是常见的，c++能够兼容c语言的编译方式，但是c++编译器g++默认会以c++的方式编译程序，而c程序编译器gcc会默认以c的方式编译它，所以c和c++的相互调用存在一定的技巧。

####1.c方式编译和c++方式编译
一般.cpp文件是采用g++去编译，.c文件是采用gcc编译，然而这不是绝对的。
(1)gcc和g++都可以编译.c文件，也都可以编译.cpp文件。g++和gcc是通过后缀名来辨别是c程序还是c++程序的(这一点与Linux辨别文件的方式不同，Linux是通过文件信息头辨别文件的)。
(2)在gcc看来，.c文件会以c方式去编译，.cpp文件则是以c++的方式去编译，注意，gcc不会主动去链接c++用到库stdc++，所以用gcc编译cpp文件时需要手动指定链接选项-lstdc++。而对于g++，不管是.c还是.cpp文件，都是以c++方式去编译。
(3)还需要注意，并不是说__cpluscplus 是g++编译器才会定义的宏，确切的说，是只有以c++编译的方式去编译文件的宏才会定义的宏，这样说来，gcc编译.cpp文件、g++编译.c、.cpp文件,这个 __cplusplus都会被编译器定义。

####2.c++调用c程序
假设c程序是之前写好的具有价值的静态库，该库是由add.o和sub.o编译而成，而add.c和sub.c是由c语言写的:
add.h和add.c

//add.h
#ifndef __ADD_H__
#define __ADD_H__
int add(int, int);
#endif /* __ADD_H__ */

//add.c
#include "add.h"

int add(int a, int b)
{
	return a + b;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

sub.h和sub.c

//sub.h
#ifndef __SUB_H__
#define __SUB_H__
int sub(int, int);
#endif /* __SUB_H__ */

//sub.c
#include <stdio.h>
#include "sub.h"
int sub(int a, int b)
{
    printf("%d - %d = %d\n", a, b, a - b);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

将各自编译成.o文件，并打包成静态库

$ gcc -c add.c
$ gcc -c sub.c
$ ar cqs libadd.a *.o
1
2
3

这样就生成了libadd.a静态库。
若要编译成动态库，则

$ gcc -shared -fPIC *.o -o libadd.so
1

main.cpp是c++写的，用g++编译。

//main.cpp
#include "add.h"
#include "sub.h"
#include <stdio.h>

int main(void)
{
    int c = add(1, 6);
    sub(8, 2);
    printf("c = %d\n", c);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

编译:

报错未定义的add和sub函数。
通过nm确实是可以看到add和sub标号的存在的:

原因在于，main.cpp是c++文件，用g++编译器编译时(gcc也是一样的结果)，会优先选择cpp的编译方式，也就是会用cpp的编译方式去编译add()、sub()函数。然而，它们是.c文件，用的是c语言的方式去编译的，所以出现如上问题。注意，cpp编译器是兼容c语言的编译方式的，所以在编译cpp文件的时候，调用到.c文件的函数的地方时，需要用extern "C"指定用c语言的方式去编译它:

//使得add.h、sub.h里面的代码用c语言的方式去编译
extern "C"{
#include "add.h"
#include "sub.h"
}
#include <stdio.h>
int main(void)
{
    int c = add(1, 6);
    printf("c = %d\n", c);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

编译运行

特别注意extern "C"是c++方式编译才认识的关键字。

####3. c语言调用c++程序
c语言用c方式编译，c++程序用c++方式，要使得c语言能调用c++程序无非有2种方法(c++调用c也是一样)
(1) c语言程序用c++方式编译
既然是c语言调用c++程序，肯定是要采取c++方式编译，所以觉得这个没什么意义。操作很简单，用g++方式编译c程序即可，注意，g++会对语法、类型等更为严格的检查。
(2) c++程序用c语言方式编译
a. c方式编译和c++方式编译，其差异就在于符号表标识符。同一个函数名，在c方式编译的其函数名跟编译前的函数一致，c++方式编译的则是以函数名结合参数作为编译后的函数名。要确保文件以.c方式编译，可以利用__cplusplus，这个宏在c++编译的方式才会定义的宏，结合之前的extern C用法如下：

#ifdef __cplusplus
extern "C"{
#endif /* __cplusplus */

//用c方式编译的代码

#ifdef __cplusplus
}
#endif /* __cplusplus */
1
2
3
4
5
6
7
8
9

这样，对于一份.c文件，采用gcc编译时候没有定义__cplusplus，宏判断不起作用，且自是用c语言的方式编译，采用g++编译定义了_cplusplus，经过上面宏判断，所以还是会以c语言的方式编译。注意，extern “C”是g++才具有的关键字，gcc并没有，所以如果用gcc编译而不加以宏判断直接使用extern “C”那么就会出现语法错误。
用c方式去编译c++文件，还要注意重载函数。c方式编译的c++文件决定不能出现重载函数。尝试extern “C”中出现重载函数:

#ifdef __cplusplus
extern "C"{
#endif /* __cplusplus */
int func(int a, int b){
    return a + b;
}

void func(const char* str){
    printf("str = %s\n", str);
}
#ifdef __cplusplus
}
#endif /* __cplusplus */

int main(void)
{
    func("hello");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

提示找不到func函数。在c语言中肯定不能出现同名函数，不然编译器怎么知道它要调用的是哪一个。去除extern “C”关键字，也就是使其采用c++方式编译，编译结果:

编译通过。通过nm命令可以查看可执行程序的符号表:

可见c++编译方式会将重载函数名结合参数形成唯一的函数名。但是c方式编译的可执行文件却并非如此，函数名经过编译后的符号还是之前的函数名，所以出现找不到调用函数的现象。
b. c程序要调用c++写的程序，涉及到的可能有:c程序调用c++的普通函数，c程序调用c++的重载函数，c程序调用c++的成员函数(包括虚函数)。c程序自然是采用c的方式去编译的，即是采用gcc编译器，然而c++是采用c++方式编译，所以要强制将c++代码以c的方式去编译。
(1) c程序调用c++的普通函数

add.h和add.cpp
//add.h
#ifndef _ADD_H_
#define _ADD_H_
int add(int, int);
#endif /* _ADD_H_ */
//add.cpp
#include <iostream>
extern "C" {    //以c的方式去编译
int add(int a, int b)
{
    std::cout<<"a + b = "<< a + b << std::endl;
    return 0;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注意不能在声明add函数的add.h中指定以c的方式去编译，因为add.h是要被main.c文件包含的，c方式编译时并不能认得extern “C”关键字。
main.c

//main.c
#include <stdio.h>
#include "add.h"
int main(void)
{
    add(4, 9);
    return 0;
}
1
2
3
4
5
6
7
8

编译运行:

因为add.cpp用到标准c++库，所以要手动链接该库。
(2)c调用c++的重载函数
前面已经知道，在extern “C”中是不允许出现重载函数的，因为c方式下的程序并不支持重载函数，所以需要对重载函数进行接口封装。使用extern “C”是要告诉编译器按照c的方式来编译封装接口，接口里面的函数还是按照c++的语法和c++方式编译。
add.h和add.cpp

//add.h
#ifndef _ADD_H_
#define _ADD_H_
int add_ii(int, int);
int add_c(char);
#endif /* _ADD_H_ */
1
2
3
4
5
6

上面两个函数是供c程序调用的，自然需要用c方式编译。而这两个函数的实现体可以去调用c++的重载函数，这就完美契合了。

//add.cpp
#include <iostream>
int add(int a, int b)
{
    std::cout<< "a + b = " << a + b << std::endl;
    return 0;
}

int add(char c)
{
    std::cout << "c = " << c << std::endl;
}

extern "C" int add_ii(int a, int b)  //供c程序调用，用c方式编译
{
    add(a, b);
}

extern "C" int add_c(char c)
{
    add(c);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

main.cpp

//main.cpp
#include <stdio.h>
#include "add.h"

int main(void)
{
    add_ii(4, 9);
    add_c('d');
    return 0;
}
1
2
3
4
5
6
7
8
9
10

编译运行:

(3)c程序调用c++的成员函数
这个比较复杂，先不说。