extern C 深度解析：实现 C/C++ 混合编程 – wiki大全

作者： /

“`markdown

extern “C” 深度解析：实现 C/C++ 混合编程

在现代软件开发中，C 和 C++ 常常被用于构建高性能的系统级应用程序。尽管 C++ 是 C 语言的超集，但在实际项目中，由于历史遗留代码、特定库的依赖或性能优化等原因，经常需要将 C 和 C++ 代码混合编译和链接。然而，这种混合编程并非没有挑战，其中最核心的问题之一就是 名字修饰 (Name Mangling)。extern "C" 便是解决这一兼容性问题的关键机制。

1. 名字修饰：C++ 与 C 的鸿沟

1.1 C++ 的名字修饰

C++ 是一门支持函数重载、模板、类、命名空间等高级特性的语言。为了在编译后的机器码中区分同名但参数列表不同的函数（函数重载）、不同的模板实例或不同命名空间中的实体，C++ 编译器会对函数和变量的名称进行特殊处理，将其编码成一个唯一的字符串。这个过程就是 名字修饰 (Name Mangling)，也称为 名字装饰 (Name Decoration)。

例如，一个 C++ 函数 void func(int a, char b); 经过名字修饰后，在符号表中可能变成类似 _Z4funcic 的形式。这个修饰后的名字包含了函数名、参数类型、命名空间等信息，使得链接器能够正确识别和链接。

1.2 C 语言的简洁

与 C++ 不同，C 语言不具备函数重载、类等特性。因此，C 编译器在处理函数和变量名时，会采用一种更为直接和简单的策略：它通常只在函数或变量名前添加下划线（或不添加任何前缀），不进行任何复杂的修饰。例如，一个 C 函数 void func(int a, char b); 在符号表中可能就是 _func 或 func。

1.3 冲突的根源

当 C++ 代码尝试调用 C 库中的函数，或者 C 代码尝试调用 C++ 提供的函数时，名字修饰的差异就会导致问题。C++ 编译器会按照 C++ 的名字修饰规则去寻找 C 函数的符号，而 C 函数的符号却是未修饰的 C 风格名称。反之亦然。这种不匹配会导致链接器报告 “未定义的引用 (undefined reference)” 错误，因为链接器找不到它所期望的符号。

2. extern "C"：破除藩篱的桥梁

extern "C" 是 C++ 语言提供的一种 链接指示 (linkage specification)。它的核心作用是告诉 C++ 编译器：对于被 extern "C" 包裹的函数或变量，请按照 C 语言的链接规范进行处理，而不是 C++ 的链接规范。具体来说，它实现了以下两点：

  1. 阻止名字修饰 (No Name Mangling)：C++ 编译器不会对这些函数或变量的名称进行名字修饰，而是保持其 C 风格的原始名称。
  2. 使用 C 调用约定 (C Calling Convention)：编译器会确保这些函数使用 C 语言的调用约定（如参数传递顺序、栈清理方式等），这对于跨语言调用至关重要。

2.1 extern "C" 的语法

extern "C" 可以应用于单个函数/变量声明，也可以应用于一个代码块：

单个声明：

cpp
// 告诉 C++ 编译器，这个函数是 C 语言风格的
extern "C" void c_function(int arg);
extern "C" int c_global_variable;

代码块声明：

cpp
// 告诉 C++ 编译器，这个块内的所有声明都按 C 语言风格处理
extern "C" {
void c_function_one(int arg);
int c_function_two(char* str);
// ... 更多 C 风格的声明
}

3. extern "C" 在混合编程中的应用

extern "C" 主要用于以下两种混合编程场景：

3.1 C++ 调用 C 函数

这是最常见的应用场景。当 C++ 项目需要使用已有的 C 语言库时，为了让 C++ 编译器正确链接到 C 库中未修饰的函数名，必须在 C++ 代码中声明这些 C 函数时使用 extern "C"。

示例：

假设你有一个 C 语言源文件 c_library.c 和头文件 c_library.h：

c_library.h
“`c

ifndef C_LIBRARY_H

define C_LIBRARY_H

// C 函数声明
void greet_from_c();
int add_numbers(int a, int b);

endif // C_LIBRARY_H

“`

c_library.c
“`c

include

include “c_library.h”

void greet_from_c() {
printf(“Hello from C!\n”);
}

int add_numbers(int a, int b) {
return a + b;
}
“`

现在，在你的 C++ 源文件 main.cpp 中调用这些 C 函数：

main.cpp
“`cpp

include

// 告诉 C++ 编译器，这些函数使用 C 链接
extern “C” {
void greet_from_c();
int add_numbers(int a, int b);
}

int main() {
std::cout << “Calling C functions from C++:” << std::endl;
greet_from_c(); // 调用 C 函数
int sum = add_numbers(5, 7); // 调用 C 函数
std::cout << “Sum from C function: ” << sum << std::endl;
return 0;
}
“`

在编译时，你需要分别编译 C 和 C++ 文件，然后链接它们：
gcc -c c_library.c -o c_library.o
g++ -c main.cpp -o main.o
g++ c_library.o main.o -o mixed_program

3.2 C 调用 C++ 函数

如果你想让 C 代码调用 C++ 中实现的某个函数，那么这个 C++ 函数在声明时也必须带有 extern "C"。这确保 C++ 编译器为它生成一个 C 风格的未修饰名称，以便 C 链接器能够找到它。

重要限制： 被 extern "C" 修饰的 C++ 函数，其接口必须是 C 兼容的。这意味着它不能有 C++ 特有的参数类型（如引用、类对象）、不能是类成员函数，也不能被重载。

示例：

假设你有一个 C++ 源文件 cpp_component.cpp 和头文件 cpp_component.h：

cpp_component.h
“`cpp

ifndef CPP_COMPONENT_H

define CPP_COMPONENT_H

// 使用预处理器宏来确保 extern “C” 只在 C++ 编译器下生效

ifdef __cplusplus

extern “C” {

endif

// C++ 函数，但暴露为 C 接口
void cpp_say_hello_to_c();

ifdef __cplusplus

} // end extern “C”

endif

endif // CPP_COMPONENT_H

“`

cpp_component.cpp
“`cpp

include

include “cpp_component.h”

// 实现 C++ 函数，并使用 extern “C” 链接
extern “C” void cpp_say_hello_to_c() {
std::cout << “Hello from C++ (called by C)!” << std::endl;
}
“`

现在，在你的 C 源文件 c_main.c 中调用这个 C++ 函数：

c_main.c
“`c

include

include “cpp_component.h” // 包含 C++ 组件的头文件

int main() {
printf(“Calling C++ function from C:\n”);
cpp_say_hello_to_c(); // 调用 C++ 函数
return 0;
}
“`

编译和链接：
g++ -c cpp_component.cpp -o cpp_component.o
gcc -c c_main.c -o c_main.o
g++ cpp_component.o c_main.o -o mixed_program_reverse

3.3 extern "C" 和头文件：#ifdef __cplusplus 技巧

为了方便头文件同时被 C 和 C++ 代码包含，通常会使用 #ifdef __cplusplus 预处理器宏来条件性地应用 extern "C"：

“`cpp

ifndef SOME_HEADER_H

define SOME_HEADER_H

ifdef __cplusplus // 如果是 C++ 编译器

extern “C” { // 则启用 C 链接

endif

// 这里放置所有 C 风格的函数和变量声明
void c_style_function(int param);
int c_style_variable;

ifdef __cplusplus // 如果是 C++ 编译器

} // 结束 C 链接块

endif

endif // SOME_HEADER_H

“`

这样，当 C++ 编译器包含此头文件时，extern "C" 块会生效；而当 C 编译器包含此头文件时，__cplusplus 未定义，extern "C" 块会被忽略，头文件按纯 C 方式处理，避免了编译错误。

4. extern "C" 的深度解析与注意事项

4.1 全局变量

extern "C" 同样可以应用于全局变量。这允许 C 和 C++ 模块共享同一个全局变量，而无需担心名字修饰问题。

cpp
// 在 C++ 代码中声明 C 风格的全局变量
extern "C" int shared_global_data;

4.2 函数指针

在 C/C++ 混合编程中，涉及回调函数和函数指针时，extern "C" 变得尤为重要。如果一个 C 库期望一个 C 风格的函数指针作为回调，那么在 C++ 代码中提供这个回调函数时，必须确保该函数具有 extern "C" 链接，并且函数指针的类型也应该与 C 风格兼容。

“`cpp
// C 库中的函数，期望一个 C 风格的回调
// typedef void (c_callback_t)(void data);
// void register_callback(c_callback_t cb, void* data);

// 在 C++ 中实现回调函数
extern “C” void my_cpp_callback(void* data) {
// …
}
“`

4.3 局限性

尽管 extern "C" 强大，但它并非万能，有一些重要的局限性：

  • 不能应用于 C++ 类、成员函数或模板：C 语言没有类、成员函数或模板的概念，因此 extern "C" 不能直接修饰这些 C++ 特性。如果需要从 C 代码访问 C++ 类功能，必须通过 extern "C" 修饰的普通 C 函数作为封装器 (wrapper)，这些封装器接收指向 C++ 对象的 void* 指针，然后调用 C++ 对象的成员函数。
  • 不能用于函数重载：由于 extern "C" 的作用是禁用名字修饰，所以任何被 extern "C" 修饰的函数都不能有重载版本。否则，链接器将无法区分它们。
  • 异常不能跨越 extern "C" 边界：C++ 的异常处理机制是 C++ 特有的。如果一个 extern "C" 修饰的 C++ 函数抛出异常，并且这个异常传播到了纯 C 代码中（C 代码没有异常处理机制），将会导致未定义行为，通常是程序崩溃。因此，在 extern "C" 函数中应避免抛出异常，或在内部捕获并处理。
  • 不能应用于局部变量：extern "C" 仅适用于具有外部链接的实体，即全局变量和函数。

5. 最佳实践

  • 仅在 C++ 代码中使用 extern "C"：extern "C" 是 C++ 语言的特性。在纯 C 代码中使用它会导致编译错误。
  • 使用 #ifdef __cplusplus 保护：当头文件可能被 C 和 C++ 编译器同时包含时，务必使用 __cplusplus 宏来条件性地启用 extern "C"。
  • 为 C++ 特性创建 C 兼容封装：如果需要从 C 代码访问 C++ 的高级功能（如类），设计一个简单的 C 风格 API，其中包含 extern "C" 修饰的封装函数，通过这些函数来操作 C++ 对象。
  • 保持编译器兼容性：确保 C 和 C++ 编译器在调用约定、数据结构布局等方面具有良好的兼容性，以避免潜在的运行时问题。

结论

extern "C" 是 C++ 提供的一个强大而必要的工具，它在 C/C++ 混合编程中扮演着至关重要的角色。通过理解名字修饰的原理以及 extern "C" 如何禁用它并强制 C 链接约定，开发者可以有效地在两种语言之间构建无缝的接口，从而充分利用各自的优势，实现代码的重用和项目的顺利集成。正确地使用 extern "C" 是编写健壮和高效的混合语言应用程序的关键。
``
I have written an article detailingextern “C”` for C/C++ mixed programming.

滚动至顶部