混编C和C++

C++代码中嵌入C语言，是可能的；C语言中嵌入C++也是可能的。这里将介绍如何将它们混编，
如何解决混编时出现的问题。

有些编译器不支持混编，但clang和gcc都是支持的，这里使用的就是这两种编译器。

声明链接规范

混编C和C++是C++提供的功能，所以只能在C++代码中想办法。C++编译器允许在声明中带
extern "C" ，表示按照C的方式链接，这样声明的代码可以与C交
互。 extern "language" 是可以嵌套的：

extern "C" {
  void a(); // C linkage
  extern "C++" {
    void b(); // C++ linkage
    extern "C" void c(); //  C linkage
  }
  extern "C++" void d(); // C++ linkage  
}

C++中访问C

C++中引用C必须在C的声明中带 extern "C" 。最简单的引用C语言代码的方式，是在C++
原代码文件中，在包含头文件的地方使用 extern "C" ：

// 通过将头文件包含包括在 extern "C" 中的方式，
// 将C代码的声明全部指定为 extern "C"
extern "C" {
#include "header_of_c.h"
}
// ...
// 之后便可以正常使用 C 函数
std::cout << c_code_get_string() << std::endl;

如果你希望你的C代码可以被C或C++引用，可以在C头文件中将所有声明放在
extern "C"
大括号里，但C编译器不认识这个语法，需要在C编译器使用头文件的时候，就排除掉
extern "C" ，C++编译器使用头文件的时候，就包含
extern "C" 。所有的C++编译器
都预定义了宏 __cplusplus ，所以在C的头文件可以是如下结构：

// 这是几乎每个头文件都需要的，保证头文件只被包含一次
#ifndef xxx_HEADER_GUARD_H_
#define xxx_HEADER_GUARD_H_

// 如果使用C++编译器，则将头文件中所有声明包含在 extern "C" 中
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus

// ... body of header

#ifdef __cplusplus
} // closing brace for extern "C"
#endif // __cplusplus

#endif // xxx_HEADER_GUARD_H_

有时候，你可能希望使用C++的方式使用一个C的数据结构，这就需要使用派生。声明一个
C++的类，以C的数据结构为父类，再定义成员函数，在成员函数中直接调用C的操作函数即
可。

// 在 C 代码 buf.h 中
struct buf {
  char *data;
  size_t len;
};
int buf_print(struct buf* buf);
int buf_compare(struct buf* a, struct buf* b);
// ...
// 在C++代码中
extern "C" {
#include "buf.h"
}
class BufInCPP : public buf {
  BufInCPP(): data(0), len(0) {}
  int print() { return buf_print(this); }
  int compare() { return buf_compare(this); }
};

这样，就将一个C的数据结构转化为C++的数据结构。这不是必须的，但这能让C++代码拥有
更统一的接口。需要注意的是，在析构结构时，要认真考虑是否需要让C代码释放内存(free)。

在C中访问C++

用 extern "C" 声明的函数可以被C访问。例如，有一个C++函数:

int print(int i, double d) {
  std::cout << "i=" << i << ", d=" << d;
}

在头文件中，可以将其声明为 =extern "C"= :

#ifdef __cplusplus
extern "C"
#endif
int print(int i, double d);

这样，C语言代码只要包含这个头文件，就可以使用 print() 函数了。

C++是支持多态和模板的，同一个函数名可以输入不同的参数类型，但C不能那
么做，需要区分函数名才能使用多态或者模板的C++函数。例如，在C++代码中，有一个模板
函数f()，要让C语言能访问这个函数，需要重新写几个函数包含它，曲线救国：

template<typename T>
T f(T v) {/* ... */}

int f_int(int v) { return f(v); }
double f_double(double v) { return f(v); }

在和C语言共享的头文件中，需要添加 extern "C" 声明：

#ifdef __cplusplus
extern "C" {
#endif

int f_int(int v);
double f_double(double v);

#ifdef __cplusplus
}
#endif

C访问C++类

要访问C++类，最好的办法是将C++类包含在C的数据结构中，或者在提供C的接口时，使用
void* 来表示对象的类型。也有直接使用的办法，没有多少区别。

假设有一个C++类：

class A {
public:
  int f();
// ...
};
// 定义C语言接口函数
int A_f(A* a) { return a->f(); }

在C的头文件中，要这样声明：

#ifdef __cplusplus
extern "C" {
#endif
struct A;
int A_f(struct A); 
#ifdef __cplusplus
}
#endif

这样就可以通过调用 A_f() 来调用 A::f() 了。

函数指针

函数指针在混编C和C++时容易出错，C++有时候不知道函数指针参数到底是C还是C++。

typedef int (*fn)(int);
extern "C" void caller(fn);
extern "C" int my_fn(int);
// ...
caller(my_fn); // 编译错误

上面的例子中，fn 是指向C++函数的指针，my_fn 是 C 的函数，这是个类型错误。要编译
通过，只需将相关函数都声明成C的链接方式：

extern "C" {
typedef int (*fn)(int);
void caller(fn);
int my_fn(int);
}
caller(my_fn); // 编译成功

异常和long_jmp

最好的方法就是不要抛出异常，不要使用 long_jmp。如果必须要使用的话，异常不要超出
C++的范围，long_jmp不要跨越C++代码。

编译和链接

C语言代码使用 C 编译器编译，C++代码使用C++编译器编译。生成的 .o 或者 .a 文件
正常使用C编译器链接即可。

CC -c a.c
CXX -c b.cpp
CC -o programname a.o b.o

阅读原文