Unsafe Rust：安全有效地使用它的完整指南

Rust 是一种强大的系统编程语言，以其内存安全保证和严格的编译器检查而闻名，这些检查可以防止分段错误、缓冲区溢出和数据竞争等常见问题。然而，在某些情况下，你需要绕过这些限制以进行性能优化、低级编程或与外部系统交互。这就是 unsafe Rust 发挥作用的地方。

在本综合指南中，我们将探讨：

• 什么是 unsafe Rust 及其存在的原因
• 何时在程序中使用 unsafe Rust
• unsafe 解锁的 5 个关键功能
• 编写安全 unsafe Rust 的最佳实践
• 常见错误以及如何避免未定义行为

通过本指南，你将对如何有效使用 unsafe Rust，同时保持代码的可靠性和效率有一个扎实的理解。

🚀 什么是 Unsafe Rust？

Rust 的借用检查器确保引用、指针和内存访问始终是安全的。然而，在某些情况下，编译器无法验证内存安全性，你需要进行手动控制。unsafe 关键字允许你：

• 解引用裸指针（*const T 和 *mut T）
• 调用 unsafe 函数（包括 C FFI）
• 访问或修改可变静态变量
• 实现 unsafe traits
• 处理 union 字段

💡 重要提示：使用 unsafe 并非完全禁用 Rust 的安全检查。相反，它允许 Rust 通常禁止的操作，而你将负责确保内存安全。

🛠️ 何时应该使用 Unsafe Rust？

unsafe 只有在绝对必要时才应使用。以下是一些 unsafe Rust 必不可少的常见用例：

1️⃣ 与 C 代码交互 (Foreign Function Interface — FFI)

当使用 C 库时，Rust 无法保证内存安全，因为它不控制外部代码。unsafe 允许你手动调用外部函数。

extern "C" {
    fn puts(s: *const i8);
}

fn main() {
    let msg = b"Hello from Rust!\0".as_ptr() as *const i8;
    unsafe {
        puts(msg);
    }
}

2️⃣ 用于性能优化的裸指针

在游戏引擎或操作系统等高性能应用程序中，你可能希望使用裸指针来绕过 Rust 借用检查器的开销。

fn sum_array(arr: &[i32]) -> i32 {
    let mut sum = 0;
    let ptr = arr.as_ptr(); // Convert to raw pointer
    for i in 0..arr.len() {
        unsafe {
            sum += *ptr.add(i); // Dereference with manual indexing
        }
    }
    sum
}

3️⃣ 低级内存管理（自定义分配器）

如果你正在构建内存分配器、无锁数据结构或操作系统内核，你将需要 unsafe。

struct MyBox<T> {
    ptr: *mut T,
}

impl<T> MyBox<T> {
    fn new(value: T) -> Self {
        let ptr = Box::into_raw(Box::new(value));
        MyBox { ptr }
    }

    fn get(&self) -> &T {
        unsafe { &*self.ptr }
    }
}

4️⃣ 处理静态可变性

Rust 不允许可变全局变量，但可以使用 unsafe 修改 static mut 变量。

static mut COUNTER: i32 = 0;

fn increment_counter() {
    unsafe {
        COUNTER += 1;
        println!("Counter: {}", COUNTER);
    }
}

5️⃣ 实现 Unsafe Traits

某些 traits 无法保证安全（例如 Send, Sync），因此需要 unsafe。

unsafe trait MyUnsafeTrait {
    fn dangerous_function(&self);
}

✅ 安全使用 Unsafe Rust 的最佳实践

由于 unsafe Rust 可能会引入未定义行为，你应遵循以下最佳实践：

🔹 1. 最小化 Unsafe 范围

尽可能使你的 unsafe 块保持小范围，并将它们封装在安全的 Rust 函数中。

fn get_first_element(slice: &[i32]) -> Option<i32> {
    if slice.is_empty() {
        None
    } else {
        Some(unsafe { *slice.as_ptr() }) // Only this line is unsafe
    }
}

🔹 2. 使用安全封装器封装 Unsafe 代码

将 unsafe 逻辑封装在安全的 API 中以防止误用。

struct SafePtr<T> {
    ptr: *mut T,
}

impl<T> SafePtr<T> {
    fn new(value: T) -> Self {
        let boxed = Box::new(value);
        Self { ptr: Box::into_raw(boxed) }
    }

    fn get(&self) -> &T {
        unsafe { &*self.ptr }
    }
}

🔹 3. 避免解引用空指针或悬空指针

在解引用裸指针之前，务必检查是否为空。

fn safe_dereference(ptr: *const i32) -> Option<i32> {
    if ptr.is_null() {
        None
    } else {
        Some(unsafe { *ptr })
    }
}

4. 遵循 Rust 的 Unsafe 代码指南 (UCG)

请参阅 Rust Unsafe Code Guidelines 以避免内存损坏、数据竞争和未定义行为。

🔹 5. 仅在必要时在库中使用 Unsafe

除非绝对必要，否则避免在公共 API 中暴露 unsafe 函数。

❌ Unsafe Rust 中的常见错误（避免这些！）

🚫 解引用无效指针

let x: *const i32 = std::ptr::null();
unsafe {
    println!("{}", *x); // 🚨 Undefined behavior!
}

🚫 在没有同步的情况下从多个线程修改数据

static mut DATA: i32 = 0;

fn race_condition() {
    unsafe {
        DATA += 1; // 🚨 Possible data race!
    }
}

🚫 无故使用unsafe

unsafe {
    let x = 42;
    println!("{}", x); // ❌ This is already safe Rust!
}

🔥 何时使用 Unsafe Rust？

✅ 在以下情况下使用 unsafe：

• 与 C 库交互 (FFI)
• 高性能优化（游戏引擎、数据库）
• 低级内存管理（自定义分配器、操作系统内核）
• 实现 unsafe traits

🚫 在以下情况下避免使用 unsafe：

• 它只是绕过 Rust 安全规则的捷径
• 可以使用安全的 Rust 实现相同的功能

💡 结论

Rust 的 unsafe 模式是一个强大的工具，但必须谨慎使用。始终优先使用安全的 Rust，仅在绝对必要时才使用 unsafe。

✅ 主要收获：

• unsafe 允许手动内存管理和 FFI 调用。
• 始终最小化unsafe 块并将其封装在安全抽象中。
• 遵循 Rust 的 Unsafe 代码指南以防止未定义行为。

🔗 你在 unsafe Rust 方面的经验是什么？让我们在评论中讨论！🚀

通过遵循这些指南和最佳实践，你可以利用 unsafe Rust 的强大功能，同时保持 Rust 以其闻名的安全性和可靠性。无论你是从事高性能系统、低级编程还是 FFI，本指南都将帮助你安全有效地使用 unsafe Rust。编码愉快！🦀

• 原文链接： aarambhdevhub.medium.com...
• 登链社区 AI 助手，为大家转译优秀英文文章，如有翻译不通的地方，还请包涵～