Rust 2026 经验谈 - Unsafe 的哲学与边界

1
// 不好：大块 unsafe，无法审计
2
unsafe fn process(data: *const u8, len: usize) -> Vec<u8> {
3
    // Edition 2024: unsafe fn 函数体需显式 unsafe {}
4
    let slice = unsafe {
5
        // SAFETY: 调用者保证 data 指向 len 个有效已初始化字节
6
        std::slice::from_raw_parts(data, len)
7
    };
8
    let mut result = Vec::with_capacity(len);
9
    for &byte in slice {
10
        result.push(byte.wrapping_add(1));
11
    }
12
    result
13
}
14

15
// 好：unsafe 块仅包裹必要的操作，其余在安全代码中
16
fn process(data: *const u8, len: usize) -> Vec<u8> {
17
    let slice = unsafe {
18
        // SAFETY: 调用者保证 data 指向 len 个有效已初始化字节
19
        std::slice::from_raw_parts(data, len)
20
    };
21
    // 后续操作全是安全代码
22
    let mut result = Vec::with_capacity(len);
23
    for &byte in slice {
24
        result.push(byte.wrapping_add(1));
25
    }
26
    result
27
}

1
mod raw_buffer {
2
    pub struct RawBuffer {
3
        ptr: *mut u8,
4
        len: usize,
5
        cap: usize,
6
    }
7

8
    impl RawBuffer {
9
        pub fn new(cap: usize) -> Self {
10
            let layout = std::alloc::Layout::array::<u8>(cap).unwrap();
11
            let ptr = unsafe {
12
                // SAFETY: layout.size() > 0（cap > 0），全局分配器有效
13
                std::alloc::alloc(layout)
14
            };
15
            if ptr.is_null() {
16
                std::alloc::handle_alloc_error(layout);
17
            }
18
            RawBuffer { ptr, len: 0, cap }
19
        }
20

21
        pub fn push(&mut self, byte: u8) {
22
            if self.len < self.cap {
23
                unsafe {
24
                    // SAFETY: len < cap，ptr 指向 cap 字节有效内存
25
                    std::ptr::write(self.ptr.add(self.len), byte);
26
                }
27
                self.len += 1;
28
            }
29
        }
30

31
        pub fn as_slice(&self) -> &[u8] {
32
            unsafe {
33
                // SAFETY: ptr 指向 len 个已初始化字节
34
                std::slice::from_raw_parts(self.ptr, self.len)
35
            }
36
        }
37
    }
38

39
    impl Drop for RawBuffer {
40
        fn drop(&mut self) {
41
            let layout = std::alloc::Layout::array::<u8>(self.cap).unwrap();
42
            unsafe {
43
                // SAFETY: ptr 来自 alloc，layout 匹配
44
                std::alloc::dealloc(self.ptr, layout);
45
            }
46
        }
47
    }
48
}

1
// 不好：暴露原始指针，调用者可能误用
2
pub struct Container {
3
    pub data: *mut u8,  // 公开的！
4
    pub len: usize,
5
}
6

7
// 好：原始指针是私有的，只暴露安全接口
8
pub struct Container {
9
    data: *mut u8,  // 私有
10
    len: usize,
11
    cap: usize,
12
}
13

14
impl Container {
15
    pub fn get(&self, index: usize) -> Option<&u8> {
16
        if index < self.len {
17
            unsafe {
18
                // SAFETY: index < len，data 指向 len 个有效字节
19
                Some(&*self.data.add(index))
20
            }
21
        } else {
22
            None
23
        }
24
    }
25
}

1
// Edition 2024：unsafe 块中可以直接写 impl
2
struct MyType;
3

4
// 传统写法（仍然合法）
5
// unsafe impl Send for MyType {}
6
// unsafe impl Sync for MyType {}
7

8
// 新写法一：在 unsafe 块中，省略 impl 前的 unsafe
9
unsafe {
10
    impl Send for MyType {}
11
    impl Sync for MyType {}
12
}
13

14
// 新写法二：在 unsafe fn 中也可以
15
unsafe fn assert_send_sync() {
16
    // Edition 2024: 这里可以写 impl Send/Sync
17
    // 但函数体中的 unsafe 操作仍需显式 unsafe {} 块
18
}

1
// unsafe trait 声明
2
unsafe trait TrustedAlloc {}
3

4
// unsafe impl 必须在 unsafe 上下文中
5
unsafe {
6
    impl TrustedAlloc for std::alloc::Global {}
7
}
8

9
// unsafe fn 声明
10
unsafe fn raw_read(ptr: *const u8) -> u8 {
11
    // Edition 2024: unsafe fn 函数体需显式 unsafe {}
12
    unsafe { *ptr }
13
}
14

15
// 方法中的 unsafe
16
impl MyType {
17
    // 方法声明中的 unsafe
18
    unsafe fn access_raw(&self, ptr: *const u8) -> u8 {
19
        // Edition 2024: unsafe fn 函数体需显式 unsafe {}
20
        unsafe { *ptr }
21
    }
22
}

1
pub struct MyVec<T> {
2
    ptr: *mut T,
3
    len: usize,
4
    cap: usize,
5
}
6

7
// 对外接口全是安全的
8
impl<T> MyVec<T> {
9
    pub fn new() -> Self { /* 内部用 unsafe */ }
10
    pub fn push(&mut self, val: T) { /* 内部用 unsafe */ }
11
    pub fn get(&self, i: usize) -> Option<&T> { /* 内部用 unsafe */ }
12
    pub fn len(&self) -> usize { self.len }
13
}
14

15
// 只要不通过外部手段获取 self.ptr，就不可能造成 UB

1
pub struct BuggyVec<T> {
2
    data: *mut T,
3
    len: usize,
4
    cap: usize,
5
}
6

7
impl<T> BuggyVec<T> {
8
    // Unsound！安全的 get_ptr 方法暴露了原始指针
9
    pub fn get_ptr(&self) -> *mut T {
10
        self.data  // 安全代码可以拿到原始指针
11
    }
12
}
13

14
// 调用者（安全代码）可以造成 UB：
15
let mut v = BuggyVec::new();
16
v.push(1);
17
let ptr = v.get_ptr();  // 安全代码拿到指针
18
v.push(2);              // 可能 reallocate，ptr 悬垂
19
unsafe { *ptr = 99; }   // UB！但调用者只用了安全 API