Rust

2025年10月19日更新 10 人订阅
原价: ¥ 6 限时优惠
专栏简介 Rust编程语言之错误处理 Rust 语言之 flod Rust编程语言之Cargo、Crates.io详解 Rust编程语言之枚举与模式匹配 Rust语言 - 接口设计的建议之受约束（Constrained） Rust编程语言之无畏并发 Rust语言 - 接口设计的建议之灵活（flexible） Rust语言 - 接口设计的建议之显而易见（Obvious） Rust语言 - 接口设计的建议之不意外（unsurprising） Rust 实战：构建实用的 CLI 工具 HTTPie Rust编程语言学习之高级特性 Rust内存管理揭秘：深度剖析指针与智能指针 解决Rust中数组和切片的编译时大小问题 《Rust编程之道》学习笔记一 Rust Async 异步编程 简易教程 使用 Async Rust 构建简单的 P2P 节点 Rust编程语言入门之模式匹配 Rust async 编程 Rust编程语言之编写自动化测试 Rust编程语言之函数式语言特性：迭代器和闭包 《Rust编程之道》学习笔记二 Rust Tips 比较数值 使用 Rust 开发一个微型游戏 Rust编程初探：深入理解Struct结构体 深入理解Rust中的内存管理：栈、堆与静态内存详解 深入理解 Rust 结构体：经典结构体、元组结构体和单元结构体的实现 深入掌握 Rust 结构体：从模板到实例化的完整指南 深入理解Rust中的结构体：逻辑与数据结合的实战示例 深入理解 Rust 枚举：从基础到实践 掌握Rust字符串的精髓：String与&str的最佳实践 全面解析 Rust 模块系统：实战案例与应用技巧 Rust 中的 HashMap 实战指南：理解与优化技巧 掌握Rust模式匹配：从基础语法到实际应用 Rust 中的面向对象编程：特性与实现指南 深入理解 Rust 的 Pin 和 Unpin：理论与实践解析 Rust Trait 与 Go Interface：从设计到实战的深度对比 从零开始：用 Rust 和 Axum 打造高效 Web 应用 Rust 错误处理详解：掌握 anyhow、thiserror 和 snafu Rust 如何优雅实现冒泡排序 链表倒数 K 节点怎么删？Python/Go/Rust 实战 用 Rust 玩转数据存储：JSON 文件持久化实战 Rust实战：打造高效字符串分割函数 如何高效学习一门技术：从知到行的飞轮效应 Rust 编程入门：Struct 让代码更优雅 Rust 编程：零基础入门高性能开发 用 Rust 写个猜数游戏，编程小白也能上手！ Rust 入门教程：变量到数据类型，轻松掌握！ 深入浅出 Rust：函数、控制流与所有权核心特性解析 从零开始：用 Rust 和 Axum 打造高效 Web 服务 Rust 集合类型解析：Vector、String、HashMap 深入浅出Rust：泛型、Trait与生命周期的硬核指南 Rust实战：博物馆门票限流系统设计与实现 用 Rust 打造高性能图片处理服务器：从零开始实现类似 Thumbor 的功能 Rust 编程入门实战：从零开始抓取网页并转换为 Markdown 深入浅出 Rust：高效处理二进制数据的 Bytes 与 BytesMut 实战 Rust智能指针：解锁内存管理的进阶之道 用 Rust 打造命令行利器：从零到一实现 mini-grep 解锁Rust代码组织：轻松掌握Package、Crate与Module Rust 所有权：从内存管理到生产力释放 深入解析 Rust 的面向对象编程：特性、实现与设计模式 Rust + Protobuf：从零打造高效键值存储项目 bacon 点燃 Rust：比 cargo-watch 更爽的开发体验 用 Rust 打造微型游戏：从零开始的 Flappy Dragon 开发之旅 函数式编程的Rust之旅：闭包与迭代器的深入解析与实践 探索Rust编程之道：从设计哲学到内存安全的学习笔记 精读《Rust编程之道》：吃透语言精要，彻底搞懂所有权与借用 Rust 避坑指南：搞定数值比较，别再让 0.1 + 0.2 != 0.3 困扰你！ 告别 Vec！掌握 Rust bytes 库，解锁零拷贝的真正威力 告别竞态条件：基于 Axum 和 Serde 的 Rust 并发状态管理最佳实践 Rust 异步编程实践：从 Tokio 基础到阻塞任务处理模式 Rust 网络编程实战：用 Tokio 手写一个迷你 TCP 反向代理 (minginx) 保姆级教程：Zsh + Oh My Zsh 终极配置，让你的 Ubuntu 终端效率倍增 不止于后端：Rust 在 Web 开发中的崛起之路 (2024数据解读) Rust核心利器：枚举(Enum)与模式匹配(Match)，告别空指针，写出优雅健壮的代码 Rust 错误处理终极指南：从 panic! 到 Result 的优雅之道 想用 Rust 开发游戏？这份超详细的入门教程请收好！ 用 Rust 实现 HTTPie：一个现代 CLI 工具的构建过程 Rust 异步实战：从0到1，用 Tokio 打造一个高性能并发聊天室 深入 Rust 核心：彻底搞懂指针、引用与智能指针 Rust 生产级后端实战：用 Axum + sqlx 打造高性能短链接服务 深入 Rust 内存模型：栈、堆、所有权与底层原理 Rust 核心概念解析：引用、借用与内部可变性 掌握 Rust 核心：生命周期与借用检查全解析 Rust 内存布局深度解析：从对齐、填充到 repr 属性 Rust Trait 分派机制：静态与动态的抉择与权衡 Rust Thread::Builder 用法详解：线程命名与栈大小设置 Rust 泛型 Trait：关联类型与泛型参数的核心区别 Rust Scoped Threads 实战：更安全、更简洁的并发编程 Rust 核心设计：孤儿规则与代码一致性解析 Rust 实战：从零构建一个多线程 Web 服务器 Rust Web 开发实战：构建教师管理 API 硬核实战：从零到一，用 Rust 和 Axum 构建高性能聊天服务后端 Rust Web 开发实战：使用 SQLx 连接 PostgreSQL 数据库 硬核入门：从零开始，用 Actix Web 构建你的第一个 Rust REST API (推荐 🔥) Rust 并发编程：详解线程间数据共享的几种核心方法 Rust并发安全基石：Mutex与RwLock深度解析 Rust Web实战：构建优雅的 Actix Web 统一错误处理 煮咖啡里的大学问：用 Rust Async/Await 告诉你如何边烧水边磨豆 深入浅出：Rust 原子类型与多线程编程实践 Rust 并发编程利器：OnceCell 与 OnceLock 深度解析 Rust 懒人编程：LazyCell 与 LazyLock 的惰性哲学 Rust 入门精髓：详解 Enum 的三种魔法，从模式匹配到状态管理 Rust 字符串魔法：String 与 &str 的深度解析与实践 Rust 模块化编程：驾驭代码结构与可见性的三大法则 Rust 实用进阶：深度剖析 Rust 生命周期的奥秘 Rust 智能指针大揭秘：Box、Rc、Arc、Cow 深度剖析与应用实践 Rust 并发编程三步曲：Join、Arc<Mutex> 与 mpsc 通道同步实战 Rust 声明宏实战进阶：从基础定义到 #[macro_export] 与多规则重载 Rust 类型转换实战：利用 From/Into Trait 实现带 Default 容错的安全转换 Rust 实战：实现 FromStr Trait，定制化字符串 parse() 与精确错误报告 Rust 实战：TryFrom Trait——如何在类型转换中强制执行业务逻辑检查 Rust 泛型编程基石：AsRef 和 AsMut 的核心作用与实战应用 揭秘 Rust Unsafe 编程：程序员接管内存安全的契约与实践 Rust FFI 入门：extern、ABI 与底层符号链接解析 Rust性能优化：零内存拷贝的链表合并技术实战 Rust 进阶：用 NonNull 裸指针实现高性能双向链表 O(N) 反转实战 Rust实战：如何用泛型和特性实现一个高性能、通用的插入排序 Rust实战：深度解析二叉搜索树（BST）的实现，掌握泛型与内存安全 用 Rust 优雅实现图搜索核心算法：广度优先搜索 (BFS) 实战 Rust 多线程的高效等待术：park() 与 unpark() 信号通信实战 Rust 并发加速器：用 Condvar 实现线程间“精确握手”与高效等待 Rust 算法精讲：用 DFS 玩转图遍历，从起点“一走到底”的秘密 Rust 并发实战：用 MPSC 通道构建线程安全的“任务指挥中心” 一行代码提速 30 倍！Rust Rayon 并行计算：告别多线程管理困境 Rust 实战：使用自定义泛型栈实现高效、严谨的括号匹配算法 Rust 并行加速：4 个实操案例，深度解析 Rayon 线程池的 Fork-Join 与广播机制 Rust 实战：用两个队列实现栈——重温经典数据结构面试题

Rust FFI 入门：extern、ABI 与底层符号链接解析

RustFFI入门：extern、ABI与底层符号链接解析Rust以内存安全著称，但有时我们需要打破边界，与C/C++等外部代码交互，或者直接进行底层操作，这就是外部函数接口（FFI）的用武之地。作为一篇入门指南，我们将通过一个精简的Rust代码示例，聚焦于FFI的三大基石

Rust FFI 入门：extern、ABI 与底层符号链接解析

Rust 以内存安全著称，但有时我们需要打破边界，与 C/C++ 等外部代码交互，或者直接进行底层操作，这就是 外部函数接口（FFI） 的用武之地。作为一篇入门指南，我们将通过一个精简的 Rust 代码示例，聚焦于 FFI 的三大基石：extern 块、调用约定（ABI） 和符号链接。学习如何使用它们，是您迈向 Rust 高级系统编程的关键第一步。

实操：Rust 内部的符号链接机制

Rust FFI 核心代码

// Rust is highly capable of sharing FFI interfaces with C/C++ and other statically compiled
// languages, and it can even link within the code itself! It makes it through the extern
// block, just like the code below.
//
// The short string after the `extern` keyword indicates which ABI the externally imported
// function would follow. In this exercise, "Rust" is used, while other variants exists like
// "C" for standard C ABI, "stdcall" for the Windows ABI.
//
// The externally imported functions are declared in the extern blocks, with a semicolon to
// mark the end of signature instead of curly braces. Some attributes can be applied to those
// function declarations to modify the linking behavior, such as #[link_name = ".."] to
// modify the actual symbol names.
//
// If you want to export your symbol to the linking environment, the `extern` keyword can
// also be marked before a function definition with the same ABI string note. The default ABI
// for Rust functions is literally "Rust", so if you want to link against pure Rust functions,
// the whole extern term can be omitted.
//
// Rust mangles symbols by default, just like C++ does. To suppress this behavior and make
// those functions addressable by name, the attribute #[no_mangle] can be applied.

extern "Rust" {
    fn my_demo_function(a: u32) -> u32;
    #[link_name = "my_demo_function"]
    fn my_demo_function_alias(a: u32) -> u32;
}

mod Foo {
    // No `extern` equals `extern "Rust"`.
    #[no_mangle]
    fn my_demo_function(a: u32) -> u32 {
        a
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_success() {
        // The externally imported functions are UNSAFE by default
        // because of untrusted source of other languages. You may
        // wrap them in safe Rust APIs to ease the burden of callers.
        //
        // SAFETY: We know those functions are aliases of a safe
        // Rust function.
        unsafe {
            my_demo_function(123);
            my_demo_function_alias(456);
        }
    }
}

这段 Rust 代码详细展示了 外部函数接口（FFI） 在 Rust 内部的运用，主要围绕如何使用 extern 块进行函数声明和符号链接。

核心机制和作用：

这段代码通过使用 extern "Rust" { ... } 块来导入（或声明）函数签名，尽管这些函数的实际定义 (my_demo_function) 存在于代码的另一个模块 Foo 内部。这种模式通常用于与其他语言（如 C/C++）或动态库进行交互，但在本例中，它被用于演示 Rust 内部的符号链接机制。

  1. extern 块与 ABI： extern "Rust" { ... } 定义了一个外部块，其中 "Rust" 指定了调用约定（ABI）。这意味着被声明的函数将遵循 Rust 编译器默认的调用规则。其他常见的 ABI 包括 "C"（标准 C 语言 ABI）或 "stdcall"（Windows ABI）。
  2. 符号导出与 #[no_mangle]： 在 Foo 模块内部定义的函数 my_demo_function 前使用了 #[no_mangle] 属性。通常，Rust 会像 C++ 一样对函数名进行符号重整（Name Mangling），使其在二进制文件中难以直接通过名称查找。#[no_mangle] 阻止了这一行为，确保了函数在链接环境中有一个干净、可预测的名称 (my_demo_function)。
  3. 符号别名与 #[link_name]： 在 extern 块中，my_demo_function_alias 明确使用了 #[link_name = "my_demo_function"] 属性。这告诉链接器，尽管函数在 Rust 代码中被命名为 my_demo_function_alias，但它应该链接到外部环境中名为 my_demo_function 的实际符号上。
  4. 不安全调用： 任何在 extern 块中声明的函数，无论是链接到 C 代码还是像本例中链接到 Rust 代码，默认都被视为不安全（unsafe）。这是因为编译器无法验证外部函数是否满足 Rust 的内存安全和并发安全规则。因此，在测试用例中，对 my_demo_function 及其别名的调用必须被包裹在 unsafe { ... } 块内，以此作为程序员对内存安全的承诺。

总之，这段代码是理解 Rust FFI 和链接机制的基础示例，展示了如何使用 extern、#[no_mangle] 和 #[link_name] 来控制函数符号的导入和导出，从而实现跨语言或跨模块的低级别通信。

总结

这段代码是理解 Rust FFI 和符号链接机制的绝佳示例。它展示了三个核心要素：通过 extern 确定调用约定（ABI），通过 #[no_mangle] 导出清晰的函数符号，以及通过 #[link_name] 创建符号别名。

掌握这些属性，意味着您获得了在 Rust 安全框架下，与底层内存和外部代码进行高性能、低级别通信的能力。但请务必记住，任何 FFI 调用都是对内存安全的主动接管，必须严格履行安全契约。

参考

点赞 0
收藏 0
分享
本文参与登链社区写作激励计划 ，好文好收益，欢迎正在阅读的你也加入。

0 条评论

请先 登录 后评论

寻月隐君

如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！