Rust 2026 经验谈 - 原始指针与内存操作

1
// 方式一：从引用转换（最安全）
2
let x = 42;
3
let ptr: *const i32 = &x as *const i32;        // const 指针
4
let mut y = 99;
5
let mptr: *mut i32 = &mut y as *mut i32;        // mut 指针
6

7
// 方式二：从 Box 转换（接管所有权）
8
let boxed = Box::new(42);
9
let ptr: *mut i32 = Box::into_raw(boxed);       // ptr 现在拥有内存
10
// 必须手动释放！
11
unsafe { drop(Box::from_raw(ptr)); }
12

13
// 方式三：从 Vec 转换
14
let mut v = vec![1, 2, 3];
15
let ptr: *mut i32 = v.as_mut_ptr();
16

17
// 方式四：整数转指针（最危险，通常只在内核/嵌入式）
18
let addr: usize = 0x1000;
19
let ptr: *const u8 = addr as *const u8;
20

21
// 方式五：空指针
22
let null: *const i32 = std::ptr::null();
23
let null_mut: *mut i32 = std::ptr::null_mut();

1
let mut v = vec![10, 20, 30, 40, 50];
2
let base: *mut i32 = v.as_mut_ptr();
3

4
unsafe {
5
    // 偏移：ptr.add(n) → 指向 ptr + n * size_of::<T>() 的字节
6
    let second = base.add(1);
7
    assert_eq!(*second, 20);
8

9
    // 负偏移
10
    let first = second.sub(1);
11
    assert_eq!(*first, 10);
12

13
    // 偏移量计算
14
    let offset = second.offset_from(base);
15
    assert_eq!(offset, 1);
16
}
17

18
// 安全注意：
19
// - add/sub 的结果必须在同一分配对象的范围内
20
// - add/sub 可以越界 1 位（"one-past-the-end"），但不能解引用
21
// - offset_from 要求两个指针指向同一对象

1
let v = vec![1, 2, 3];
2
let p1: *const i32 = v.as_ptr();
3
let p2: *const i32 = unsafe { p1.add(1) };
4

5
// 指针比较
6
assert!(p1 < p2);          // 同一分配对象内可以比较
7
assert_ne!(p1, p2);        // 不相等
8

9
// 判断空指针
10
assert!(!p1.is_null());
11
assert!(std::ptr::null::<i32>().is_null());
12

13
// 判断对齐
14
assert!(p1.is_aligned());
15
// p1.is_aligned_to(4)  // Nightly

1
use std::ptr;
2

3
let x = Box::new(42);
4
let ptr: *const i32 = &*x;
5

6
unsafe {
7
    // read：复制值，不运行 Drop，不使原位置失效
8
    let val = ptr::read(ptr);
9
    assert_eq!(val, 42);
10
    // x 仍然有效！因为 read 不执行 Drop
11
}
12

13
// 如果用 *ptr 读取，语义是"移动"——原位置不再有效
14
// unsafe { let val = *ptr; }  // val 被"移动"出 *ptr
15
// 此时 x 已经失效，drop(x) 会 double free

1
use std::ptr::NonNull;
2

3
struct Node<T> {
4
    data: T,
5
    next: Option<NonNull<Node<T>>>,
6
    prev: Option<NonNull<Node<T>>>,
7
}
8

9
impl<T> Node<T> {
10
    fn new(data: T) -> Self {
11
        Node {
12
            data,
13
            next: None,
14
            prev: None,
15
        }
16
    }
17
}
18

19
struct LinkedList<T> {
20
    head: Option<NonNull<Node<T>>>,
21
    tail: Option<NonNull<Node<T>>>,
22
    len: usize,
23
}
24

25
impl<T> LinkedList<T> {
26
    fn new() -> Self {
27
        LinkedList { head: None, tail: None, len: 0 }
28
    }
29

30
    fn push_front(&mut self, data: T) {
31
        let mut node = Box::new(Node::new(data));
32
        node.next = self.head;
33
        node.prev = None;
34

35
        let node_ptr = NonNull::new(Box::into_raw(node) as *mut Node<T>).unwrap();
36

37
        match self.head {
38
            Some(old_head) => unsafe {
39
                // SAFETY: old_head 来自 into_raw，保证有效
40
                (*old_head.as_ptr()).prev = Some(node_ptr);
41
            },
42
            None => self.tail = Some(node_ptr),
43
        }
44

45
        self.head = Some(node_ptr);
46
        self.len += 1;
47
    }
48
}

1
use std::alloc::Layout;
2

3
// 为单个 i32 创建 Layout：size=4, align=4
4
let layout = Layout::new::<i32>();
5
assert_eq!(layout.size(), 4);
6
assert_eq!(layout.align(), 4);
7

8
// 为数组 [i32; 10] 创建 Layout：size=40, align=4
9
let arr_layout = Layout::array::<i32>(10).unwrap();
10
assert_eq!(arr_layout.size(), 40);
11
assert_eq!(arr_layout.align(), 4);
12

13
// 手动指定 size 和 align
14
let custom = Layout::from_size_align(24, 8).unwrap();
15
assert_eq!(custom.size(), 24);
16
assert_eq!(custom.align(), 8);

1
use std::alloc::Layout;
2

3
// 1. 检查 Layout 是否合法
4
let ok = Layout::from_size_align(16, 4);
5
assert!(ok.is_ok());
6

7
let bad = Layout::from_size_align(3, 0);  // 对齐不能为 0
8
assert!(bad.is_err());
9

10
// 2. 扩展 Layout（追加另一块内存）
11
let base = Layout::new::<i32>();  // size=4, align=4
12
let extra = Layout::new::<u64>(); // size=8, align=8
13
let (combined, offset) = base.extend(extra);
14
// combined: size=16, align=8
15
// offset: extra 在 combined 中的偏移 = 8（4 padding + 4 i32）
16
assert_eq!(combined.size(), 16);
17
assert_eq!(combined.align(), 8);
18
assert_eq!(offset, 8);
19

20
// 3. 重复 Layout（注意：Layout::repeat 已弃用，推荐用 Layout::array）
21
// Layout::array::<T>(n) 创建 n 个 T 元素的数组布局
22
let repeated = Layout::array::<u32>(5).unwrap();
23
assert_eq!(repeated.size(), 20);
24
assert_eq!(repeated.align(), 4);
25

26
// 4. padding 计算
27
let pad = base.padding_needed_for(extra.align());
28
assert_eq!(pad, 4);  // i32 后需要 4 字节 padding 才能满足 u64 对齐

1
use std::alloc::{alloc, dealloc, Layout};
2

3
fn manual_alloc_example() {
4
    let layout = Layout::array::<u8>(1024).unwrap();
5

6
    let ptr = unsafe {
7
        // SAFETY: layout.size() > 0，全局分配器有效
8
        let ptr = alloc(layout);
9
        if ptr.is_null() {
10
            std::alloc::handle_alloc_error(layout);
11
        }
12
        ptr
13
    };
14

15
    // 使用分配的内存
16
    unsafe {
17
        std::ptr::write_bytes(ptr, 0, 1024);  // 零初始化
18
    }
19

20
    // 释放
21
    unsafe {
22
        // SAFETY: ptr 来自 alloc(layout)，layout 匹配
23
        dealloc(ptr, layout);
24
    }
25
}

1
// 陷阱 1：结构体的对齐不等于字段对齐的最大值
2
// 如果有 repr(align)，对齐可能更大
3
#[repr(C, align(16))]
4
struct Aligned {
5
    data: [u8; 10],  // 10 字节，但对齐到 16
6
}
7

8
assert_eq!(std::mem::size_of::<Aligned>(), 16);  // padding 到 16
9
assert_eq!(std::mem::align_of::<Aligned>(), 16);
10

11
// 陷阱 2：Vec 的缓冲区对齐
12
// Vec<T> 保证其缓冲区对齐到 align_of::<T>()
13
// 但如果你手动分配，必须确保对齐
14

15
// 陷阱 3：过度对齐的类型
16
#[repr(align(4096))]
17
struct PageAligned {
18
    data: [u8; 4096],
19
}
20
// 分配这种类型需要支持过度对齐的分配器

1
use std::mem::MaybeUninit;
2

3
fn init_array<F, T, const N: usize>(mut init: F) -> [T; N]
4
where
5
    F: FnMut(usize) -> T,
6
{
7
    let mut arr: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
8
    // 注意：[MaybeUninit<T>; N] 的 uninit 不是 [MaybeUninit::uninit(); N]
9
    // 我们需要数组的每个元素都是 uninit，但数组本身是"已初始化"的
10
    // 这里的 unsafe 是安全的，因为 MaybeUninit<T> 没有有效性要求
11

12
    let mut i = 0;
13
    while i < N {
14
        arr[i].write(init(i));
15
        i += 1;
16
    }
17

18
    unsafe { MaybeUninit::array_assume_init(arr) }
19
}
20

21
let squares: [i32; 5] = init_array(|i| (i as i32) * (i as i32));
22
assert_eq!(squares, [0, 1, 4, 9, 16]);

1
use std::mem::MaybeUninit;
2

3
// 场景：只初始化前几个元素
4
let mut arr: [MaybeUninit<i32>; 5] = unsafe { MaybeUninit::uninit().assume_init() };
5

6
arr[0].write(1);
7
arr[1].write(2);
8
// arr[2..5] 未初始化
9

10
// 不能调用 array_assume_init——需要先初始化所有元素
11
// unsafe { MaybeUninit::array_assume_init(arr) }  // UB！
12

13
// 正确：只取出已初始化的部分
14
unsafe {
15
    assert_eq!(arr[0].assume_init(), 1);
16
    assert_eq!(arr[1].assume_init(), 2);
17
}

1
use std::mem::MaybeUninit;
2

3
struct MyVec<T> {
4
    data: *mut MaybeUninit<T>,
5
    len: usize,
6
    cap: usize,
7
}
8

9
impl<T> MyVec<T> {
10
    fn new() -> Self {
11
        MyVec {
12
            data: std::ptr::null_mut(),
13
            len: 0,
14
            cap: 0,
15
        }
16
    }
17

18
    fn push(&mut self, val: T) {
19
        if self.len == self.cap {
20
            self.grow();
21
        }
22
        unsafe {
23
            // SAFETY: len < cap，data 指向 cap 个 MaybeUninit<T>
24
            self.data.add(self.len).write(MaybeUninit::new(val));
25
        }
26
        self.len += 1;
27
    }
28

29
    fn get(&self, i: usize) -> Option<&T> {
30
        if i < self.len {
31
            unsafe {
32
                // SAFETY: i < len，元素已初始化
33
                Some(&*self.data.add(i).cast::<T>())
34
            }
35
        } else {
36
            None
37
        }
38
    }
39

40
    fn grow(&mut self) {
41
        let new_cap = if self.cap == 0 { 4 } else { self.cap * 2 };
42
        let new_layout = std::alloc::Layout::array::<MaybeUninit<T>>(new_cap).unwrap();
43

44
        let new_data = if self.cap == 0 {
45
            unsafe { std::alloc::alloc(new_layout) as *mut MaybeUninit<T> }
46
        } else {
47
            let old_layout = std::alloc::Layout::array::<MaybeUninit<T>>(self.cap).unwrap();
48
            unsafe {
49
                std::alloc::realloc(
50
                    self.data as *mut u8,
51
                    old_layout,
52
                    new_layout.size(),
53
                ) as *mut MaybeUninit<T>
54
            }
55
        };
56

57
        if new_data.is_null() {
58
            std::alloc::handle_alloc_error(new_layout);
59
        }
60

61
        self.data = new_data;
62
        self.cap = new_cap;
63
    }
64
}
65

66
impl<T> Drop for MyVec<T> {
67
    fn drop(&mut self) {
68
        if self.cap == 0 { return; }
69

70
        // Drop 已初始化的元素
71
        for i in 0..self.len {
72
            unsafe {
73
                // SAFETY: i < len，元素已初始化
74
                std::ptr::drop_in_place(self.data.add(i).cast::<T>());
75
            }
76
        }
77

78
        // 释放内存
79
        let layout = std::alloc::Layout::array::<MaybeUninit<T>>(self.cap).unwrap();
80
        unsafe {
81
            std::alloc::dealloc(self.data as *mut u8, layout);
82
        }
83
    }
84
}

1
fn vec_to_raw() {
2
    let mut v: Vec<u8> = Vec::with_capacity(1024);
3

4
    // 获取指针和容量
5
    let ptr = v.as_mut_ptr();
6
    let cap = v.capacity();
7
    let len = v.len();
8

9
    // 忘记 Vec（防止 Drop）
10
    std::mem::forget(v);
11

12
    // 现在 ptr 指向的内存由我们手动管理
13
    unsafe {
14
        std::ptr::write_bytes(ptr, 0xAA, cap);  // 填充
15
    }
16

17
    // 重新构造 Vec
18
    let v2 = unsafe { Vec::from_raw_parts(ptr, len, cap) };
19
    // v2 析构时释放内存
20
}

1
use std::alloc::{alloc, dealloc, Layout};
2

3
fn raw_to_vec() {
4
    let layout = Layout::array::<u8>(1024).unwrap();
5
    let ptr = unsafe { alloc(layout) };
6
    if ptr.is_null() {
7
        panic!("allocation failed");
8
    }
9

10
    // 初始化内存
11
    unsafe {
12
        std::ptr::write_bytes(ptr, 0, 1024);
13
    }
14

15
    // 转为 Vec
16
    let v = unsafe { Vec::from_raw_parts(ptr as *mut u8, 0, 1024) };
17
    // v.capacity() == 1024, v.len() == 0
18

19
    // 用 Vec 的 API 操作
20
    v.into_iter();  // 或任何 Vec 操作
21
}

1
use std::ptr;
2

3
fn mmap_buffer(size: usize) -> (*mut u8, usize) {
4
    // 概念示例（实际需要 libc::mmap）
5
    let layout = Layout::from_size_align(size, 4096).unwrap();  // 页对齐
6
    let ptr = unsafe { alloc(layout) };
7
    if ptr.is_null() {
8
        panic!("mmap failed");
9
    }
10
    (ptr, size)
11
}
12

13
fn unmap_buffer(ptr: *mut u8, size: usize) {
14
    let layout = Layout::from_size_align(size, 4096).unwrap();
15
    unsafe {
16
        dealloc(ptr, layout);
17
    }
18
}

1
use std::mem::MaybeUninit;
2

3
struct StackBuffer<T, const N: usize> {
4
    data: [MaybeUninit<T>; N],
5
    len: usize,
6
}
7

8
impl<T, const N: usize> StackBuffer<T, N> {
9
    fn new() -> Self {
10
        StackBuffer {
11
            data: unsafe { MaybeUninit::uninit().assume_init() },
12
            len: 0,
13
        }
14
    }
15

16
    fn push(&mut self, val: T) -> Result<(), T> {
17
        if self.len >= N {
18
            return Err(val);
19
        }
20
        self.data[self.len].write(val);
21
        self.len += 1;
22
        Ok(())
23
    }
24

25
    fn as_slice(&self) -> &[T] {
26
        unsafe {
27
            // SAFETY: data[..len] 已初始化
28
            std::slice::from_raw_parts(
29
                self.data.as_ptr() as *const T,
30
                self.len,
31
            )
32
        }
33
    }
34
}
35

36
impl<T, const N: usize> Drop for StackBuffer<T, N> {
37
    fn drop(&mut self) {
38
        for i in 0..self.len {
39
            unsafe {
40
                std::ptr::drop_in_place(self.data[i].as_mut_ptr());
41
            }
42
        }
43
    }
44
}
45

46
let mut buf: StackBuffer<u8, 64> = StackBuffer::new();
47
buf.push(1).unwrap();
48
buf.push(2).unwrap();
49
assert_eq!(buf.as_slice(), &[1, 2]);