Rust unsafe 一文全功能解析

在 Rust 生态中，"安全"是贯穿始终的核心标签------编译器通过严格的所有权规则、借用检查器等机制，从根源上规避空指针、悬垂引用、数据竞争等内存安全问题。但现实开发中，部分场景需要突破安全规则的限制（如与 C 语言交互、手动管理内存、操作硬件资源等），此时 unsafe 关键字便应运而生。

需要明确的是：unsafe 并非"不安全"的代名词，它更像是 Rust 提供的"安全边界扩展工具"。它允许开发者在特定范围内绕过编译器的部分检查，但同时也将确保内存安全的责任转移给了开发者。本文将全面解析 unsafe 的核心功能、使用场景、示例代码及最佳实践，帮你彻底掌握这把"双刃剑"。

一、unsafe 的核心定位与边界

1.1 为什么需要 unsafe？

Rust 的安全机制虽强大，但存在一定局限性，以下场景必须依赖 unsafe：

操作原始指针（*mut T / *const T），实现灵活的内存访问；
调用外部语言（如 C/C++）函数（FFI 交互）；
访问或修改静态可变变量（static mut）；
实现不安全特征（unsafe trait）；
对联合体（union）成员进行读写操作；
手动管理内存（如自定义智能指针）。

1.2 安全 Rust 与 unsafe Rust 的边界

unsafe Rust 并非独立于安全 Rust 的子集，而是对安全 Rust 的补充，二者遵循以下规则：

unsafe 代码块/函数内，仍需遵守大部分 Rust 规则（如变量作用域、类型检查）；
unsafe 仅解除编译器对"特定风险操作"的检查，而非所有检查；
安全 Rust 代码可调用 unsafe 函数，但必须包裹在 unsafe 块中；
unsafe 代码的安全性由开发者保证，编译器不再为其兜底。

二、unsafe 核心功能解析（附示例代码）

2.1 原始指针操作

Rust 提供两种原始指针类型：*mut T（可变原始指针）和 *const T（不可变原始指针）。与安全 Rust 中的引用（&T / &mut T）不同，原始指针不受借用检查器约束，可进行解引用、指针运算等操作，但这些操作必须在 unsafe 块中完成。

2.1.1 原始指针的创建与解引用

原始指针可通过"引用转指针"（&T as *const T / &mut T as *mut T）或直接从内存地址创建，解引用时需确保指针指向有效内存（非空、非悬垂）。

rust 复制代码

fn main() {
    // 安全场景：从引用创建原始指针
    let mut num = 42;
    let const_ptr: *const i32 = &num as *const i32; // 不可变原始指针
    let mut_ptr: *mut i32 = &mut num as *mut i32;   // 可变原始指针

    // 解引用原始指针必须在 unsafe 块中
    unsafe {
        println!("不可变指针解引用: {}", *const_ptr); // 输出：42
        *mut_ptr = 100; // 修改值
        println!("可变指针解引用: {}", *mut_ptr);   // 输出：100
    }

    // 直接从内存地址创建指针（风险极高，需确保地址有效）
    let raw_addr = 0x7ffeefbff5fc; // 示例地址，实际需根据环境调整
    let ptr_from_addr: *const i32 = raw_addr as *const i32;
    unsafe {
        // 仅作演示，实际可能因地址无效触发崩溃
        if !ptr_from_addr.is_null() {
            println!("地址创建的指针解引用: {}", *ptr_from_addr);
        }
    }
}

2.1.2 指针运算与切片转换

原始指针支持偏移（offset）、加减等运算，常用于连续内存块（如数组）的访问。需注意：指针运算必须确保结果指向有效内存，否则会导致内存越界。

rust 复制代码

fn main() {
    let arr = [10, 20, 30, 40, 50];
    let ptr: *const i32 = arr.as_ptr(); // 从数组获取原始指针

    unsafe {
        // 指针偏移：offset 参数为"元素个数"，非字节数
        let ptr_2 = ptr.offset(2);
        println!("偏移 2 个元素: {}", *ptr_2); // 输出：30

        // 指针加减运算
        let ptr_3 = ptr_2 + 1;
        println!("指针加 1: {}", *ptr_3); // 输出：40

        // 从指针和长度创建切片（安全 Rust 可直接使用）
        let slice = std::slice::from_raw_parts(ptr, 5);
        println!("切片内容: {:?}", slice); // 输出：[10, 20, 30, 40, 50]

        // 可变版本：from_raw_parts_mut
        let mut mut_arr = [10, 20, 30];
        let mut_ptr = mut_arr.as_mut_ptr();
        let mut_slice = std::slice::from_raw_parts_mut(mut_ptr, 3);
        mut_slice[1] = 200;
        println!("修改后切片: {:?}", mut_slice); // 输出：[10, 200, 30]
    }
}

2.2 unsafe 函数与代码块

当函数内部包含 unsafe 操作时，可将其声明为 unsafe fn，明确告知调用者：该函数需手动保证安全性。调用 unsafe 函数时，必须包裹在 unsafe 块中。

2.2.1 定义与调用 unsafe 函数

rust 复制代码

//  unsafe 函数：接收原始指针，返回解引用后的值
unsafe fn deref_ptr(ptr: *const i32) -> i32 {
    *ptr // 解引用操作，需在 unsafe 环境中
}

fn main() {
    let num = 99;
    let ptr = &num as *const i32;

    // 调用 unsafe 函数，必须包裹在 unsafe 块中
    let result = unsafe {
        deref_ptr(ptr)
    };
    println!("调用 unsafe 函数结果: {}", result); // 输出：99
}

2.2.2 缩小 unsafe 范围（最佳实践）

应尽量将 unsafe 操作限制在最小范围内，而非将整个函数声明为 unsafe。这样可减少安全风险，也便于代码审计。

rust 复制代码

// 安全函数：内部包裹小范围 unsafe 块
fn safe_deref(ptr: *const i32) -> Option<i32> {
    if ptr.is_null() {
        return None;
    }
    // 仅解引用操作在 unsafe 块中
    unsafe {
        Some(*ptr)
    }
}

fn main() {
    let num = 123;
    let ptr = &num as *const i32;
    let null_ptr: *const i32 = std::ptr::null();

    println!("有效指针结果: {:?}", safe_deref(ptr)); // 输出：Some(123)
    println!("空指针结果: {:?}", safe_deref(null_ptr)); // 输出：None
}

2.3 静态可变变量（static mut）

Rust 中的静态变量（static）默认不可变，且生命周期为整个程序运行期。若需修改静态变量，需声明为 static mut，但对其访问和修改必须在 unsafe 块中进行------因为多线程环境下，无同步的修改会导致数据竞争。

rust 复制代码

// 静态可变变量：全局可修改，需 unsafe 访问
static mut GLOBAL_COUNT: i32 = 0;

fn increment_global() {
    // 修改静态可变变量，必须在 unsafe 块中
    unsafe {
        GLOBAL_COUNT += 1;
    }
}

fn main() {
    increment_global();
    increment_global();

    // 读取静态可变变量，也需 unsafe 块
    unsafe {
        println!("全局计数: {}", GLOBAL_COUNT); // 输出：2
    }

    // 多线程场景（风险演示，无同步会导致数据竞争）
    use std::thread;
    let handles = (0..4).map(|_| {
        thread::spawn(|| {
            for _ in 0..1000 {
                increment_global();
            }
        })
    }).collect::<Vec<_>>();

    for handle in handles {
        handle.join().unwrap();
    }

    unsafe {
        println!("多线程后计数: {}", GLOBAL_COUNT); // 结果可能小于 4000（数据竞争）
    }
}

注意：使用 static mut 时，需通过互斥锁（如 Mutex）或原子类型（如 AtomicI32）保证线程安全，避免数据竞争。

2.4 不安全特征（unsafe trait）

当特征（trait）的实现可能破坏内存安全时，需声明为 unsafe trait。实现 unsafe trait 时，必须使用 unsafe 关键字，且需手动保证实现逻辑符合安全契约。

Rust 标准库中的 Send 和 Sync 就是典型的 unsafe trait：

Send：标记类型可安全跨线程传递所有权；
Sync：标记类型可安全跨线程共享引用。

rust 复制代码

// 定义 unsafe trait：要求实现者保证"数据可安全跨线程共享"
unsafe trait UnsafeSync {
    fn shared_op(&self);
}

// 实现 unsafe trait，必须加 unsafe
unsafe impl UnsafeSync for i32 {
    fn shared_op(&self) {
        println!("i32 共享操作: {}", self);
    }
}

// 自定义类型实现 UnsafeSync
struct MyData {
    value: i32,
}

// 手动保证 MyData 可安全跨线程共享（无可变状态）
unsafe impl UnsafeSync for MyData {
    fn shared_op(&self) {
        println!("MyData 共享操作: {}", self.value);
    }
}

fn main() {
    let data = MyData { value: 456 };
    // 调用 unsafe trait 的方法，无需额外 unsafe（实现时已保证安全）
    data.shared_op(); // 输出：MyData 共享操作: 456

    // 跨线程传递 MyData（因实现了 UnsafeSync，需手动保证安全）
    use std::thread;
    let handle = thread::spawn(move || {
        data.shared_op();
    });
    handle.join().unwrap();
}

2.5 联合体（Union）操作

联合体（union）是 C 语言风格的类型，多个成员共享同一块内存空间。Rust 支持定义 union，但对其成员的读写必须在 unsafe 块中进行------因为编译器无法保证成员访问的安全性（如写入一个成员后读取另一个成员，可能导致类型错误）。

rust 复制代码

// 定义联合体：3 个成员共享 4 字节内存（i32 占 4 字节）
union MyUnion {
    int_val: i32,
    float_val: f32,
    byte_val: u8,
}

fn main() {
    let mut union = MyUnion { int_val: 0x12345678 };

    unsafe {
        // 读取不同成员，展示内存共享特性
        println!("int_val: {}", union.int_val); // 输出：305419896
        println!("float_val: {}", union.float_val); // 输出：对应二进制的浮点数
        println!("byte_val: 0x{:x}", union.byte_val); // 输出：0x78（低字节）

        // 修改成员
        union.float_val = 3.14;
        println!("修改后 int_val: {}", union.int_val); // 输出：浮点数二进制对应的整数
    }
}

2.6 外部函数接口（FFI）交互

Rust 可通过 FFI（Foreign Function Interface）调用 C/C++ 等外部语言函数，而 FFI 交互本质上是"信任外部代码"，因此必须使用 unsafe 关键字------编译器无法验证外部函数的内存安全性。

2.6.1 调用 C 语言函数

首先创建 C 语言文件（如 lib.c），定义待调用函数，再通过 Rust 的 extern "C" 块声明并调用。

lib.c 代码：

c 复制代码

#include <stdio.h>

// C 语言函数：计算两数之和
int c_add(int a, int b) {
    return a + b;
}

// C 语言函数：打印字符串
void c_print(const char* msg) {
    printf("C 打印: %s\n", msg);
}

Rust 代码（Cargo.toml 需配置链接）：

rust 复制代码

// Cargo.toml 配置（静态链接 C 代码）
// [build-dependencies]
// cc = "1.0"

// build.rs（编译 C 代码）
// fn main() {
//     cc::Build::new().file("src/lib.c").compile("libc_lib.a");
// }

// Rust 代码
extern "C" {
    // 声明 C 语言函数
    fn c_add(a: i32, b: i32) -> i32;
    fn c_print(msg: *const u8);
}

fn main() {
    // 调用 C 函数，必须在 unsafe 块中
    unsafe {
        let sum = c_add(10, 20);
        println!("C 函数计算结果: {}", sum); // 输出：30

        // 传递字符串给 C 函数（需转为 C 风格字符串，以 '\0' 结尾）
        let msg = b"Hello from Rust\0"; // 字节串，末尾加 '\0'
        c_print(msg.as_ptr()); // 输出：C 打印: Hello from Rust
    }
}

三、unsafe 拓展知识点

3.1 unsafe 的安全契约

使用 unsafe 时，开发者需遵守以下核心契约，否则会导致内存安全问题：

原始指针解引用前，必须确保指针指向有效、对齐且未被释放的内存；
避免悬垂指针：指针指向的内存被释放后，不可再解引用或传递；
遵守别名规则：可变原始指针（*mut T）活跃时，不可存在其他指向同一内存的指针或引用；
静态可变变量访问需保证线程安全，避免数据竞争；
外部函数调用需确保参数类型、内存布局与外部语言一致。

3.2 unsafe 与性能的关系

很多开发者误以为 unsafe 能提升性能，但实际并非绝对：

安全 Rust 中的引用、切片操作已被编译器高度优化，与 unsafe 原始指针性能几乎无差异；
unsafe 仅在"需要手动优化内存布局"（如自定义紧凑数据结构）或"避免安全检查的额外开销"（如高频调用的底层函数）时，可能带来微弱性能提升；
盲目使用 unsafe 可能引入安全漏洞，得不偿失。

3.3 常见 unsafe 陷阱

3.3.1 悬垂指针陷阱

rust 复制代码

fn create_dangling_ptr() -> *mut i32 {
    let mut num = 5;
    &mut num as *mut i32 // num 离开作用域被释放，返回的指针悬垂
}

fn main() {
    let dangling_ptr = create_dangling_ptr();
    unsafe {
        // 解引用悬垂指针，行为未定义（可能崩溃、乱码）
        println!("{}", *dangling_ptr);
    }
}

3.3.2 数据竞争陷阱

多线程环境下，无同步的 static mut 访问会导致数据竞争，触发未定义行为。解决方式：使用 std::sync::Mutex 或原子类型（std::sync::atomic）。

rust 复制代码

use std::sync::atomic::{AtomicI32, Ordering};

// 原子类型：线程安全，无需 unsafe 访问
static ATOMIC_COUNT: AtomicI32 = AtomicI32::new(0);

fn increment_atomic() {
    ATOMIC_COUNT.fetch_add(1, Ordering::SeqCst);
}

fn main() {
    use std::thread;
    let handles = (0..4).map(|_| {
        thread::spawn(|| {
            for _ in 0..1000 {
                increment_atomic();
            }
        })
    }).collect::<Vec<_>>();

    for handle in handles {
        handle.join().unwrap();
    }

    println!("原子计数: {}", ATOMIC_COUNT.load(Ordering::SeqCst)); // 输出：4000（正确）
}

四、unsafe 最佳实践

4.1 最小化 unsafe 范围

将 unsafe 操作限制在最小代码块中，避免扩散。例如：在安全函数内部包裹小范围 unsafe 块，而非将整个函数声明为 unsafe。

4.2 完善文档注释

对 unsafe 函数、代码块添加详细注释，说明：为什么需要 unsafe、安全契约是什么、调用者需注意哪些事项。

rust 复制代码

/// 从原始指针创建切片
/// 
/// # 安全契约
/// 1. `ptr` 必须指向有效、对齐的内存
/// 2. `len` 必须是合法长度，确保指针偏移不越界
/// 3. 内存生命周期需由调用者保证，避免悬垂
unsafe fn slice_from_ptr(ptr: *const i32, len: usize) -> &'static [i32] {
    std::slice::from_raw_parts(ptr, len)
}

4.3 充分测试与审计

unsafe 代码是 bug 高发区，需针对性编写测试用例（如边界值测试、线程安全测试），必要时进行代码审计，确保符合安全契约。

4.4 优先使用安全替代方案

尽量避免手动编写 unsafe 代码，优先使用标准库或成熟 crate 提供的安全 API。例如：

使用 AtomicI32 替代 static mut i32；
使用 Vec 替代手动管理原始指针数组；
使用 std::ffi::CString 替代手动构造 C 风格字符串。

五、总结

Rust 的 unsafe 并非"打破安全规则"的工具，而是"在可控范围内扩展能力"的桥梁。它允许开发者突破编译器的安全限制，应对 FFI 交互、内存优化等复杂场景，但同时也将内存安全的责任转移给了开发者。

掌握 unsafe 的核心是：理解其安全边界、遵守安全契约、最小化使用范围。在实际开发中，应秉持"能不用则不用，非用不可则慎⽤"的原则，让 unsafe 成为解决问题的"最后手段"，而非首选方案。

通过本文的解析与示例，相信你已对 unsafe 的功能、场景及最佳实践有了全面认识。后续在编写 unsafe 代码时，务必多思考"安全契约"，让每一行 unsafe 代码都经得起推敲。