C++ `extern “C”` 的高级应用：C 与 C++ 混合编程的边界

C++ `extern "C"` 的高级应用：C 与 C++ 混合编程的边界

大家好！今天我们来聊聊一个在 C++ 和 C 混合编程中非常重要，但又经常让人头疼的家伙：extern "C"。相信不少同学在项目里都见过它，可能也用过，但到底它是什么，为什么需要它，以及更高级的应用场景，可能就没那么清楚了。

今天，咱们就来扒一扒 extern "C" 的底裤，看看它到底能干些什么，以及在混合编程的边界上，我们应该注意哪些问题。

1. 为什么要用 extern "C"？名词解释时间到！

简单来说，extern "C" 的作用就是告诉 C++ 编译器： "嘿，哥们，这里面的东西是 C 语言写的，你别用 C++ 的方式去编译它！"

那为什么 C++ 编译器要用自己的方式编译？这就涉及到 C++ 的一个重要特性：名字修饰 (Name Mangling)。

C 语言编译时，函数名就是函数名，变量名就是变量名，原汁原味，童叟无欺。但是 C++ 为了支持函数重载 (Function Overloading)，允许我们定义多个同名但参数列表不同的函数，编译器就需要在编译的时候，对函数名进行一些 "化妆"，给它加上参数类型、返回值类型等信息，生成一个唯一的符号 (Symbol)。

比如，在 C 语言里，一个名为 my_function 的函数，编译后在目标文件里可能还是 my_function。但是在 C++ 里，如果 my_function 的参数是 int，编译器可能会把它 "化妆" 成类似 _Z11my_functioni 这样的东西。这就是名字修饰。

问题来了，如果 C++ 代码想调用 C 语言的代码，C++ 编译器会按照 C++ 的名字修饰规则去查找函数，结果发现根本找不到！因为 C 语言的代码根本没有被 "化妆" 过，名字不一样啊！

所以，extern "C" 就派上用场了。它可以告诉 C++ 编译器，这个函数是 C 语言的，不要进行名字修饰，按照 C 语言的方式去查找。

代码示例：

// C 语言代码 (my_c_file.c)
int my_c_function(int a, int b) {
  return a + b;
}

// C++ 代码 (my_cpp_file.cpp)
extern "C" {
  int my_c_function(int a, int b); // 声明 C 语言函数
}

int main() {
  int result = my_c_function(1, 2); // 调用 C 语言函数
  return 0;
}

在这个例子中，extern "C" 确保了 C++ 编译器按照 C 语言的方式去查找 my_c_function 函数，从而成功调用了 C 语言的代码。

2. extern "C" 的用法：简单粗暴但很有效！

extern "C" 主要有两种用法：

单个声明： 就像上面的例子，用 extern "C" {} 包裹单个函数声明。
代码块声明： 用 extern "C" {} 包裹一段代码，这段代码中的所有函数声明都会被视为 C 语言函数。

代码示例：

// C++ 代码 (my_cpp_file.cpp)
extern "C" {
  int my_c_function1(int a, int b);
  void my_c_function2(char* str);
  // 更多 C 语言函数声明...
}

int main() {
  int result = my_c_function1(1, 2);
  char message[] = "Hello from C++!";
  my_c_function2(message);
  return 0;
}

3. 条件编译：让代码更灵活！

有时候，我们可能需要编写既能被 C++ 编译器编译，也能被 C 编译器编译的代码。这时候，我们可以使用条件编译来实现。

#ifdef __cplusplus
extern "C" {
#endif

  int my_c_function(int a, int b);

#ifdef __cplusplus
}
#endif

这段代码的意思是：

如果定义了 __cplusplus 宏 (C++ 编译器会自动定义这个宏)，就使用 extern "C" {} 包裹 my_c_function 的声明。
否则 (也就是 C 编译器)，就不使用 extern "C" {}。

这样，无论使用 C 编译器还是 C++ 编译器，都能正确编译这段代码。

4. C++ 类和 extern "C"：小心陷阱！

C++ 类是 C 语言没有的概念。 C++ 类包含了成员变量和成员函数，而且成员函数可以重载，还可以是虚函数。这些特性都会影响名字修饰。

因此，不能直接在 extern "C" {} 中声明 C++ 类。这样做会导致编译器无法正确处理 C++ 类的成员函数。

错误示例：

// 错误的代码！
extern "C" {
  class MyClass { // 错误！不能在 extern "C" 中声明 C++ 类
  public:
    MyClass(int value);
    int getValue();
  private:
    int m_value;
  };
}

那如果 C 语言代码需要访问 C++ 类的功能怎么办？这时候，我们需要使用 桥接函数 (Bridge Function)。

正确示例：

// C++ 类 (my_cpp_class.h)
class MyClass {
public:
  MyClass(int value);
  int getValue();
private:
  int m_value;
};

// C++ 类实现 (my_cpp_class.cpp)
#include "my_cpp_class.h"

MyClass::MyClass(int value) : m_value(value) {}

int MyClass::getValue() {
  return m_value;
}

// 桥接函数 (my_cpp_bridge.cpp)
#include "my_cpp_class.h"

extern "C" {
  MyClass* create_my_class(int value) {
    return new MyClass(value);
  }

  int get_my_class_value(MyClass* obj) {
    return obj->getValue();
  }

  void delete_my_class(MyClass* obj) {
    delete obj;
  }
}

// C 语言代码 (my_c_file.c)
#include <stdio.h>

// 声明桥接函数
extern MyClass* create_my_class(int value);
extern int get_my_class_value(MyClass* obj);
extern void delete_my_class(MyClass* obj);

int main() {
  MyClass* obj = create_my_class(10);
  int value = get_my_class_value(obj);
  printf("Value: %dn", value);
  delete_my_class(obj);
  return 0;
}

在这个例子中，我们定义了三个桥接函数：

create_my_class: 用于创建 MyClass 对象。
get_my_class_value: 用于获取 MyClass 对象的 value 值。
delete_my_class: 用于销毁 MyClass 对象。

这些桥接函数都是 C 语言函数，可以在 extern "C" {} 中声明，从而被 C 语言代码调用。

5. C++ 异常和 extern "C"：跨越边界的风险！

C++ 异常处理机制是 C 语言没有的。如果 C++ 代码抛出了异常，而这个异常没有被 C++ 代码捕获，而是跨越了 extern "C" 的边界，传递到了 C 语言代码中，就会导致程序崩溃！

这是因为 C 语言代码根本不知道如何处理 C++ 异常。

所以，在 C 和 C++ 混合编程中，一定要小心处理异常。尽量在 C++ 代码中捕获所有可能抛出的异常，避免异常跨越 extern "C" 的边界。

代码示例：

// C++ 代码 (my_cpp_file.cpp)
#include <iostream>
#include <stdexcept>

extern "C" {
  int my_cpp_function(int a) {
    try {
      if (a < 0) {
        throw std::runtime_error("Invalid argument");
      }
      return a * 2;
    } catch (const std::exception& e) {
      std::cerr << "C++ Exception caught: " << e.what() << std::endl;
      return -1; // 返回一个错误码
    } catch (...) {
      std::cerr << "Unknown C++ Exception caught!" << std::endl;
      return -1; // 返回一个错误码
    }
  }
}

在这个例子中，my_cpp_function 函数可能会抛出 std::runtime_error 异常。我们使用 try-catch 块捕获了这个异常，并返回一个错误码。这样，即使 C++ 代码抛出了异常，也不会导致 C 语言代码崩溃。

6. 函数指针和 extern "C"：灵活的回调机制！

函数指针在 C 和 C++ 中都是常用的技术。我们可以使用函数指针来实现回调机制，让 C 语言代码调用 C++ 代码，或者让 C++ 代码调用 C 语言代码。

但是，在使用函数指针时，也要注意 extern "C" 的问题。如果函数指针指向的是 C++ 函数，那么在传递函数指针的时候，需要使用 extern "C" 来避免名字修饰的问题。

代码示例：

// C 语言代码 (my_c_file.c)
typedef void (*CallbackFunction)(int);

void call_callback(CallbackFunction callback, int value) {
  callback(value);
}

// C++ 代码 (my_cpp_file.cpp)
#include <iostream>

extern "C" {
  void my_cpp_callback(int value) {
    std::cout << "C++ Callback called with value: " << value << std::endl;
  }
}

extern "C" {
  typedef void (*CallbackFunction)(int);
  void call_callback(CallbackFunction callback, int value);
}

int main() {
  call_callback(my_cpp_callback, 123);
  return 0;
}

在这个例子中，call_callback 函数接受一个函数指针 callback 作为参数。 my_cpp_callback 函数是 C++ 函数，但是我们使用了 extern "C" 来声明它，从而避免了名字修饰的问题。这样，C 语言代码就可以成功调用 C++ 函数了。

7. 总结：掌握边界，灵活应用！

extern "C" 是 C 和 C++ 混合编程中一个非常重要的工具。它可以解决 C++ 名字修饰带来的问题，让 C 语言代码可以调用 C++ 代码，或者让 C++ 代码可以调用 C 语言代码。

但是，在使用 extern "C" 的时候，也要注意一些问题：

不能在 extern "C" {} 中声明 C++ 类。
要小心处理 C++ 异常，避免异常跨越 extern "C" 的边界。
在使用函数指针时，要注意 extern "C" 的问题。

总而言之，掌握 extern "C" 的用法，理解 C 和 C++ 的差异，才能在混合编程中游刃有余，写出高效、稳定的代码。

表格总结：

特性/问题	解决方法/注意事项
C++ 名字修饰	使用 `extern "C"` 声明 C 语言函数
C++ 类	使用桥接函数
C++ 异常	在 C++ 代码中捕获异常，返回错误码
函数指针	使用 `extern "C"` 声明 C++ 函数

希望今天的讲解对大家有所帮助！记住，编程就像练武功，掌握了基础，才能练成绝世神功！谢谢大家！

C++ extern "C" 的高级应用：C 与 C++ 混合编程的边界

发表回复 取消回复

C++ `extern "C"` 的高级应用：C 与 C++ 混合编程的边界

发表回复取消回复