1.1 什么是extern “C”

extern "C"是C++中的一个链接规范（Linkage Specification），用于指示编译器按照C语言的规则来编译和链接特定的代码块或函数。它的主要作用是实现C++代码与C语言代码的互操作。

1.2 extern关键字的基本作用

在C和C++中，extern关键字都用于声明外部符号（变量或函数），告诉编译器：

• 该符号的定义在其他文件中
• 编译器在链接时需要从其他模块查找该符号的定义 🎯 extern “C”的核心作用

2.1 解决名称修饰问题

extern "C"的核心作用是避免C++的名称修饰（Name Mangling），这是C++支持函数重载的关键机制。

2.2 实现C++与C的互操作

extern "C"通过禁用名称修饰，使得C++代码可以：

• 调用C语言编写的函数和访问C语言的全局变量
• 被C语言编写的代码调用 💻 extern “C”的使用语法

3.1 修饰单个函数

1
// 声明C语言函数
2
extern "C" int add(int a, int b);
3
// 定义C语言风格的函数
4
extern "C" int subtract(int a, int b) {
5
    return a - b;
6
}

3.2 修饰代码块

1
// 修饰多个函数
2
extern "C" {
3
    int multiply(int a, int b);
4
    int divide(int a, int b);
5
    void print_result(int result);
6
}

3.3 在头文件中使用

在混合编程中，头文件需要同时支持C和C++编译，通常使用条件编译：

1
#ifdef __cplusplus
2
extern "C" {
3
#endif
4

5
// C函数声明
6
int add(int a, int b);
7
void print_message(const char* msg);
8

9
#ifdef __cplusplus
10
}
11
#endif

🔍 extern “C”的工作原理

4.1 编译阶段

当编译器遇到extern "C"时，会：

1. 对于声明：记录该符号需要按照C语言规则链接
2. 对于定义：生成C语言风格的符号名，不进行名称修饰

4.2 链接阶段

链接器在链接时：

1. 对于C++代码中声明为extern "C"的符号，会查找C语言风格的符号名
2. 对于C代码中调用的C++函数，要求该函数在C++中声明为extern "C" 🛠️ 具体使用场景

5.1 场景1：C++调用C代码

示例：

1
// c_library.h (C语言头文件，同时支持C++)
2
#ifdef __cplusplus
3
extern "C" {
4
#endif
5

6
int add(int a, int b);
7
void print_message(const char* msg);
8

9
#ifdef __cplusplus
10
}
11
#endif

1
// c_library.c (C语言实现)
2
#include "c_library.h"
3
#include <stdio.h>
4

5
int add(int a, int b) {
6
    return a + b;
7
}
8

9
void print_message(const char* msg) {
10
    printf("Message: %s\n", msg);
11
}

1
// cpp_program.cpp (C++调用C代码)
2
#include "c_library.h" // 包含C语言头文件
3
#include <iostream>
4

5
int main() {
6
    // 调用C语言函数
7
    int result = add(10, 20);
8
    std::cout << "10 + 20 = " << result << std::endl;
9

10
    print_message("Hello from C++");
11
    return 0;
12
}

5.2 场景2：C代码调用C++代码

1
// cpp_library.h (头文件，同时支持C和C++)
2
#ifdef __cplusplus
3
extern "C" {
4
#endif
5

6
// 声明可以被C调用的C++函数
7
void cpp_function(const char* msg);
8

9
#ifdef __cplusplus
10
}
11
#endif

1
// cpp_library.cpp (C++实现)
2
#include "cpp_library.h"
3
#include <iostream>
4

5
// 使用extern "C"声明，让C代码可以调用
6
extern "C" void cpp_function(const char* msg) {
7
    std::cout << "C++ function called with: " << msg << std::endl;
8
}
9

10
// C++内部使用的函数（不暴露给C）
11
void internal_cpp_function() {
12
    // 仅C++内部使用
13
}

1
// c_program.c (C调用C++代码)
2
#include "cpp_library.h" // 包含声明了extern "C"的头文件
3

4
int main() {
5
    // 调用C++函数
6
    cpp_function("Hello from C");
7
    return 0;
8
}

5.3 场景3：在C++中使用C库

许多系统库和第三方库都是用C语言编写的，例如：

• 标准C库（如stdio.h、stdlib.h）
• 系统API（如Windows API、POSIX API）
• 第三方库（如OpenSSL、SQLite） 在C++中使用这些库时，编译器会自动处理extern "C"，因为这些库的头文件已经包含了适当的extern "C"声明。 ⚠️ extern “C”的注意事项

6.1 函数重载与extern “C”

extern "C"与函数重载不能同时使用，因为：

• 函数重载依赖于名称修饰
• extern "C"禁用了名称修饰
• 因此，同一个函数名只能有一个extern "C"版本

1
// 错误：不能对重载函数使用extern "C"
2
// extern "C" int add(int a, int b); // 假设已存在
3
// extern "C" double add(double a, double b); // 编译错误：重复的extern "C"声明
4

5
// 正确：可以有一个extern "C"版本和一个C++版本
6
extern "C" int add(int a, int b); // C版本，无名称修饰
7
double add(double a, double b); // C++版本，会被名称修饰

6.2 类成员函数不能使用extern “C”

类成员函数不能直接使用extern "C"，因为：

• 类成员函数隐含了this指针参数
• C语言不支持this指针
• C语言不支持类的概念 如果需要让C代码调用C++类的成员函数，可以使用包装函数：

1
// C++类
2
class Calculator {
3
public:
4
    int add(int a, int b) {
5
        return a + b;
6
    }
7
};
8

9
// 全局实例
10
Calculator calc;
11

12
// 包装函数，供C语言调用
13
extern "C" int calculator_add(int a, int b) {
14
    return calc.add(a, b);
15
}

6.3 变量的extern “C”

extern "C"也可以用于变量声明：

1
// C++文件中声明C语言变量
2
extern "C" int global_count;

1
// C文件中定义变量
2
int global_count = 0;

6.4 头文件的正确使用

• 对于同时被C和C++包含的头文件，必须使用条件编译包裹extern "C"
• 否则，C编译器会将extern "C"视为语法错误 ⚖️ extern与extern “C”的区别 | 特性 | extern | extern “C” | |------|--------|-------------| | 适用语言 | C和C++ | 主要用于C++ | | 作用 | 声明外部符号 | 声明外部符号并指示C语言链接规则 | | 名称修饰 | 不影响名称修饰 | 禁用名称修饰 | | 函数重载 | 支持 | 不支持 | | 互操作性 | 仅同语言 | 支持跨语言 | 🌟 最佳实践

8.1 1. 始终在头文件中使用extern “C”

将extern "C"声明放在头文件中，而不是源文件中，确保所有包含该头文件的源文件都能正确处理链接规则。

8.2 2. 使用条件编译

在头文件中使用#ifdef __cplusplus条件编译，确保头文件同时兼容C和C++编译器。

8.3 3. 避免过度使用extern “C”

只对需要与C语言交互的函数使用extern "C"，C++内部函数不需要使用。

8.4 4. 注意函数签名匹配

确保C和C++之间调用的函数签名完全匹配，包括：

• 函数名
• 参数类型和数量
• 返回类型
• 调用约定（如__cdecl、__stdcall等）

8.5 5. 避免在extern “C”块中声明C++特有的类型

extern "C"块中应只包含C语言兼容的类型，避免使用C++特有的类型如std::string、std::vector等。 📋 总结

9.1 extern “C”的核心要点

1. 解决名称修饰问题：禁用C++的名称修饰，生成C语言风格的符号名
2. 实现跨语言调用：允许C++代码调用C代码，反之亦然
3. 链接规范：是一种链接规范，影响编译器生成的符号名
4. 与函数重载不兼容：因为它禁用了名称修饰
5. 主要用于混合编程：在C++项目中使用C库或为C项目提供C++库时使用

9.2 何时使用extern “C”

• 当C++代码需要调用C语言编写的函数时
• 当需要让C语言代码调用C++函数时
• 当编写需要被C和C++共同使用的库时
• 当使用C语言编写的系统库或第三方库时

9.3 关键结论

extern "C"是C++中实现跨语言互操作的重要机制，通过理解其工作原理和正确使用，可以避免链接错误，实现C和C++代码之间的无缝调用。在混合编程场景中，正确使用extern "C"是确保代码可移植性和正确性的关键。 通过遵循最佳实践，开发者可以在C++项目中充分利用C语言库的资源，同时保持代码的清晰性和可维护性。