C 调用 Rust 的过程

文章结构（详细解释 C 调用 Rust 的过程）

1. 前言：为什么需要让 C 调用 Rust？

   • C 和 Rust 之间的互操作性应用场景。
   • 为什么在 C 代码中调用 Rust 函数可能是有意义的？

2. Rust 和 C 的互操作：基本概念介绍

   • FFI：外部函数接口，允许 C 代码调用 Rust 函数，或 Rust 代码调用 C 函数。
   • extern 关键字：Rust 中的接口声明，告诉编译器某个函数是由外部（如 C 语言）定义的。

3. 如何暴露 Rust 函数给 C 调用：完整的示例

   • C 代码定义：如何从 C 调用 Rust 函数。
   • Rust 函数暴露接口：如何在 Rust 中使用 extern "C" 来暴露函数给 C。
   • 连接 C 与 Rust：如何通过 extern "C" 创建可供 C 调用的 Rust 函数。

4. 详细步骤：如何让 C 调用 Rust 函数

   • 步骤 1：定义 C 函数。
   • 步骤 2：通过 extern "C" 声明 Rust 函数。
   • 步骤 3：创建 C 的头文件（如果需要）以供 C 调用。
   • 步骤 4：链接 Rust 代码到 C 程序。
   • 步骤 5：编译和运行 C 程序调用 Rust 函数。

5. 示例代码与讲解

   • C 代码调用 Rust 函数的完整示例：

     • 如何调用 Rust 函数，处理返回值等。

6. 总结

   • 解释整个过程的核心步骤，并总结如何安全、高效地进行跨语言调用。

1. 前言：为什么需要让 C 调用 Rust？

C 和 Rust 都是高性能语言，Rust 提供了内存安全的优势，但某些系统级应用可能已经使用 C 或 C++ 编写，并且它们的代码库非常庞大，不能轻易重写。为了在现有的 C 系统中利用 Rust 的优势，我们需要能够将 Rust 函数暴露给 C 代码调用。

2. Rust 和 C 的互操作：基本概念介绍

FFI（Foreign Function Interface）

FFI 是一种机制，允许不同编程语言之间互相调用函数。在 C 中调用 Rust 代码，或者反过来，都是通过 FFI 实现的。在 Rust 中，使用 extern "C" 语法来声明外部 C 函数，C 调用 Rust 函数，Rust 会将其定义为 extern "C" 函数。

extern 关键字

extern 是 Rust 中用于声明外部函数接口的关键字。它表示函数的实现是在外部的（在 C/C++ 中定义），Rust 编译器不能直接看到它的实现，所以通过 extern "C" 来告知编译器，这些函数在 C 语言环境中存在。

extern "C" {
    pub fn add(a: i32, b: i32) -> i32;
}

3. 如何暴露 Rust 函数给 C 调用：完整的示例

C 代码定义

首先，假设我们有以下 C 函数，用来计算两个整数的和：

// C 代码：add.c
#include <stdio.h>

// 声明一个外部函数
int add(int a, int b) {
    return a + b;
}

这是一个标准的 C 函数，我们将把它暴露给 Rust 调用。

Rust 函数暴露接口

为了让 C 能调用 Rust 函数，我们需要在 Rust 中声明一个接口。通过 extern "C"，我们声明 Rust 函数供 C 使用。这样，我们就为 C 提供了一个“入口点”来调用 Rust 函数。

// Rust 代码：main.rs
#[no_mangle] // 防止 Rust 编译器修改函数名称
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

在上面的代码中：

• #[no_mangle] 告诉 Rust 编译器不要修改这个函数的名称，因为 C 编译器可能会使用该名称进行调用。
• extern "C" 表明这是一个可以被 C 调用的函数。
• pub 关键字使得 Rust 中的 add 函数对外部可见。

连接 C 与 Rust

接下来，我们需要链接 C 代码和 Rust 代码。Rust 可以通过 Cargo.toml 配置来链接 C 编译器生成的目标文件。

1. 在 C 代码中声明我们要调用的 Rust 函数：

   // C 代码：使用 Rust 中的 add 函数
   extern int add(int a, int b);  // 声明 Rust 的 add 函数
   
   int main() {
       int result = add(2, 3);  // 调用 Rust 函数
       printf("Result: %d\n", result);
       return 0;
   }
   

2. 使用 gcc 或 clang 来编译和链接 C 代码与 Rust 代码。确保你正确地链接了 Rust 生成的库。

4. 详细步骤：如何让 C 调用 Rust 函数

步骤 1：定义 C 函数

C 函数本身的定义就像我们在前面所展示的那样，它负责做一些计算，返回一个结果。

步骤 2：通过 extern "C" 声明 Rust 函数

Rust 函数需要用 extern "C" 来声明，并通过 #[no_mangle] 来避免名称变更。这样 C 代码就可以调用它。

步骤 3：创建 C 的头文件（如果需要）

如果你需要使用头文件来定义接口，你可以在 C 中使用 extern 声明 Rust 函数：

// C 头文件：rust_functions.h
extern int add(int a, int b);

步骤 4：链接 Rust 代码到 C 程序

我们需要在 C 项目的编译过程中，链接到 Rust 编译的输出。比如使用 gcc 链接 C 和 Rust 生成的库文件：

gcc main.c -L/path/to/rust/output -l rustlib -o main

这里的 -L 是指定库的路径，-l 是链接 Rust 库。

步骤 5：编译和运行 C 程序调用 Rust 函数

最后，你就可以通过运行 C 程序来调用 Rust 函数了。C 程序会调用 Rust 函数并打印出结果。

./main

输出：

Result: 5

5. 示例代码与讲解

完整的示例代码：

• C 代码：定义 add 函数并调用 Rust 中的 add 函数。
• Rust 代码：暴露 add 函数给 C 调用。

// Rust: main.rs
#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

// C: main.c
#include <stdio.h>

extern int add(int a, int b);

int main() {
    int result = add(5, 10);
    printf("Result from Rust function: %d\n", result);
    return 0;
}

6. 总结

• extern "C" 关键字用来声明外部 C 函数，允许 C 调用 Rust 函数。
• #[no_mangle] 确保函数名称不被 Rust 编译器更改，以便 C 可以通过原始名称调用它。
• FFI（Foreign Function Interface） 使 Rust 和 C 代码可以互相调用，而无需重写整个代码库。

通过这些步骤，我们能够清楚地在 C 中调用 Rust 函数，并且能理解 C 和 Rust 如何通过 FFI 建立联系。