《深入Rust系统编程》11.1 调用C/C++代码

Rust 系统编程实战：11.1 调用 C/C++ 代码

Rust 是一种现代系统编程语言，具有内存安全和高性能的特点。然而，在实际开发中，我们经常需要与现有的 C/C++ 代码进行集成，以利用现有的库或与遗留系统进行交互。Rust 提供了强大的工具和特性来支持与 C/C++ 代码的互操作。本文将深入探讨如何在 Rust 中调用 C/C++ 代码，涵盖基本概念、工具链配置、FFI（Foreign Function Interface）的使用、以及实际示例。

11.1.1 Rust 与 C/C++ 互操作概述

11.1.1.1 什么是 FFI？

FFI（Foreign Function Interface）是一种允许编程语言调用其他编程语言函数的机制。Rust 通过 FFI 支持与 C/C++ 代码的互操作，允许 Rust 代码调用 C/C++ 函数，反之亦然。

11.1.1.2 Rust 与 C/C++ 互操作的优势

  • 利用现有库：通过调用 C/C++ 代码，可以利用现有的库和工具。
  • 与遗留系统集成：通过与 C/C++ 代码的互操作，可以与遗留系统进行集成。
  • 性能优化：在某些情况下，C/C++ 代码可能比 Rust 代码更高效，通过调用 C/C++ 代码可以优化性能。

11.1.2 调用 C 代码

11.1.2.1 使用 libc 调用 C 标准库函数

libc 是 Rust 中的一个库，提供了对 C 标准库的绑定。以下是一个使用 libc 调用 C 标准库函数的示例。

11.1.2.1.1 添加依赖

在 Cargo.toml 中添加 libc 依赖：

1
2

[dependencies]
libc = "0.2"

11.1.2.1.2 调用 C 标准库函数

以下是一个使用 libc 调用 C 标准库函数的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

use libc::{c_char, c_int, strlen};

extern "C" {
    fn puts(s: *const c_char) -> c_int;
}

fn main() {
    let s = "Hello, world!\0".as_ptr() as *const c_char;
    unsafe {
        puts(s);
    }
}
代码说明
  1. libc::c_char：C 语言中的 char 类型。
  2. libc::c_int：C 语言中的 int 类型。
  3. strlen：C 标准库中的 strlen 函数。
  4. puts：C 标准库中的 puts 函数，用于输出字符串。

11.1.2.2 使用 cc 编译 C 代码并调用

cc 是一个用于编译 C 代码的 Rust 库。以下是一个使用 cc 编译 C 代码并调用的示例。

11.1.2.2.1 添加依赖

在 Cargo.toml 中添加 cc 依赖：

1
2

[build-dependencies]
cc = "1.0"

11.1.2.2.2 编写 C 代码

在项目根目录下创建一个 src/hello.c 文件，内容如下：

1
2
3
4
5

#include <stdio.h>

void hello() {
    printf("Hello from C!\n");
}

11.1.2.2.3 编写 Rust 代码

在 src/main.rs 中编写 Rust 代码：

1
2
3
4
5
6
7
8
9

extern "C" {
    fn hello();
}

fn main() {
    unsafe {
        hello();
    }
}

11.1.2.2.4 配置构建脚本

在项目根目录下创建一个 build.rs 文件，内容如下：

1
2
3
4
5

fn main() {
    cc::Build::new()
        .file("src/hello.c")
        .compile("hello");
}
代码说明
  1. cc::Build::new：创建一个新的 C 代码构建器。
  2. .file("src/hello.c")：指定要编译的 C 文件。
  3. .compile("hello")：编译 C 代码并生成静态库。

11.1.2.3 使用 bindgen 自动生成 Rust 绑定

bindgen 是一个用于自动生成 Rust 绑定的工具，可以根据 C/C++ 头文件生成 Rust 代码。以下是一个使用 bindgen 自动生成 Rust 绑定的示例。

11.1.2.3.1 添加依赖

在 Cargo.toml 中添加 bindgen 依赖：

1
2

[build-dependencies]
bindgen = "0.59"

11.1.2.3.2 编写 C 代码

在项目根目录下创建一个 src/hello.h 文件，内容如下：

1
2
3
4
5
6

#ifndef HELLO_H
#define HELLO_H

void hello();

#endif

11.1.2.3.3 编写 Rust 代码

在 src/main.rs 中编写 Rust 代码：

1
2
3
4
5
6
7

include!(concat!(env!("OUT_DIR"), "/bindings.rs"));

fn main() {
    unsafe {
        hello();
    }
}

11.1.2.3.4 配置构建脚本

在项目根目录下创建一个 build.rs 文件，内容如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

extern crate bindgen;

use std::env;
use std::path::PathBuf;

fn main() {
    let bindings = bindgen::Builder::default()
        .header("src/hello.h")
        .generate()
        .expect("Unable to generate bindings");

    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
    bindings
        .write_to_file(out_path.join("bindings.rs"))
        .expect("Couldn't write bindings!");
}
代码说明
  1. bindgen::Builder::default：创建一个新的 bindgen 构建器。
  2. .header("src/hello.h")：指定要生成绑定的 C 头文件。
  3. .generate()：生成 Rust 绑定。
  4. .write_to_file：将生成的 Rust 绑定写入文件。

11.1.3 调用 C++ 代码

11.1.3.1 使用 cxx 调用 C++ 代码

cxx 是一个用于 Rust 与 C++ 互操作的库，提供了安全的接口来调用 C++ 代码。以下是一个使用 cxx 调用 C++ 代码的示例。

11.1.3.1.1 添加依赖

在 Cargo.toml 中添加 cxx 依赖：

1
2

[dependencies]
cxx = "1.0"

11.1.3.1.2 编写 C++ 代码

在项目根目录下创建一个 src/hello.cpp 文件，内容如下：

1
2
3
4
5
6
7

#include <iostream>

extern "C" {
    void hello() {
        std::cout << "Hello from C++!" << std::endl;
    }
}

11.1.3.1.3 编写 Rust 代码

在 src/main.rs 中编写 Rust 代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

use cxx::let_cxx_string;

#[cxx::bridge]
mod ffi {
    extern "C" {
        fn hello();
    }
}

fn main() {
    unsafe {
        ffi::hello();
    }
}

11.1.3.1.4 配置构建脚本

在项目根目录下创建一个 build.rs 文件，内容如下：

1
2
3
4
5

fn main() {
    cxx_build::bridge("src/main.rs")
        .file("src/hello.cpp")
        .compile("hello");
}
代码说明
  1. cxx::bridge：定义一个 C++ 桥接模块。
  2. extern "C"：声明 C++ 函数。
  3. cxx_build::bridge：编译 C++ 代码并生成 Rust 绑定。

11.1.3.2 使用 cpp 宏调用 C++ 代码

cpp 是一个用于在 Rust 中嵌入 C++ 代码的宏。以下是一个使用 cpp 宏调用 C++ 代码的示例。

11.1.3.2.1 添加依赖

在 Cargo.toml 中添加 cpp 依赖：

1
2

[dependencies]
cpp = "0.5"

11.1.3.2.2 编写 Rust 代码

在 src/main.rs 中编写 Rust 代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

use cpp::cpp;

cpp! {{
    #include <iostream>

    void hello() {
        std::cout << "Hello from C++!" << std::endl;
    }
}}

fn main() {
    unsafe {
        cpp!([] {
            hello();
        });
    }
}
代码说明
  1. cpp!：在 Rust 中嵌入 C++ 代码。
  2. cpp!([] { ... })：调用嵌入的 C++ 代码。

11.1.4 总结

Rust 提供了强大的工具和特性来支持与 C/C++ 代码的互操作。本文详细介绍了如何在 Rust 中调用 C/C++ 代码，涵盖基本概念、工具链配置、FFI 的使用、以及实际示例。通过调用 C/C++ 代码，开发者可以利用现有的库和工具，与遗留系统进行集成，并优化性能。