指针偏移计算 ​

核心概念 ​

指针偏移计算是通过对裸指针加减偏移量来访问内存中不同位置的数据。Rust 提供了 add、sub、offset、byte_add、byte_sub 等方法来进行指针偏移。这些操作是 unsafe 的,因为编译器无法验证偏移后的指针是否仍然指向有效的内存区域。

指针偏移以"元素"为单位,而不是字节。对 *const i32 调用 .add(1) 会使指针前进 4 字节(一个 i32 的大小),而不是 1 字节。这与 C 语言中的指针算术行为一致。如果需要按字节偏移,使用 byte_add / byte_sub 方法。

rust
fn main() {
    let data = [10, 20, 30, 40, 50];
    let ptr = data.as_ptr();  // *const i32

    // add(n):前进 n 个元素(不是字节)
    // 对于 *const i32,add(1) = 前进 4 字节
    // SAFETY: 所有偏移在数组范围内
    unsafe {
        println!("ptr.add(0) = {}", *ptr.add(0));  // 10
        println!("ptr.add(1) = {}", *ptr.add(1));  // 20
        println!("ptr.add(2) = {}", *ptr.add(2));  // 30
        println!("ptr.add(4) = {}", *ptr.add(4));  // 50
    }

    // 验证偏移是以元素为单位
    let addr0 = ptr as usize;
    let addr1 = unsafe { ptr.add(1) } as usize;
    println!("\n地址差: {} 字节 (i32 大小={})",
        addr1 - addr0,
        std::mem::size_of::<i32>());
}

偏移方法一览 ​

rust
fn main() {
    let mut data = [100, 200, 300, 400, 500];
    let ptr = data.as_ptr();
    let mut_ptr = data.as_mut_ptr();

    // === add(count):前进 count 个元素 ===
    // SAFETY: ptr.add(2) 在数组范围内
    let val = unsafe { *ptr.add(2) };
    println!("add(2) = {}", val);  // 300

    // === sub(count):后退 count 个元素 ===
    let end_ptr = unsafe { ptr.add(4) };  // 指向最后一个元素
    // SAFETY: end_ptr.sub(2) 在数组范围内
    let val = unsafe { *end_ptr.sub(2) };
    println!("end.sub(2) = {}", val);  // 300

    // === offset(count):有符号偏移(正=前进,负=后退)===
    let mid_ptr = unsafe { ptr.add(2) };  // 指向 300
    // SAFETY: 偏移后仍在数组范围内
    unsafe {
        println!("mid.offset(1) = {}", *mid_ptr.offset(1));   // 400
        println!("mid.offset(-1) = {}", *mid_ptr.offset(-1)); // 200
    }

    // === byte_add / byte_sub:按字节偏移 ===
    let byte_ptr = data.as_ptr() as *const u8;
    // SAFETY: 按字节偏移 4 字节 = 前进 1 个 i32
    let val_ptr = unsafe { byte_ptr.byte_add(4) } as *const i32;
    let val = unsafe { *val_ptr };
    println!("byte_add(4) = {}", val);  // 200

    // === wrapping_add / wrapping_sub:不检查溢出 ===
    // 不会触发 UB,但结果指针可能无效
    let wrapped = ptr.wrapping_add(2);
    // SAFETY: wrapped 恰好在有效范围内
    println!("wrapping_add(2) = {}", unsafe { *wrapped });

    // === offset_from:计算两个指针之间的距离 ===
    let start = data.as_ptr();
    let third = unsafe { start.add(2) };
    // SAFETY: start 和 third 指向同一个数组
    let distance = unsafe { third.offset_from(start) };
    println!("offset_from = {} 个元素", distance);
}
方法参数类型单位方向溢出行为
add(n)usize元素前进UB
sub(n)usize元素后退UB
offset(n)isize元素正/负UB
byte_add(n)usize字节前进UB
byte_sub(n)usize字节后退UB
wrapping_add(n)usize元素前进回绕(不 UB)
wrapping_sub(n)usize元素后退回绕(不 UB)
offset_from(other)*const T元素计算差要求同一分配

偏移的安全规则 ​

rust
fn main() {
    let data = [1, 2, 3, 4, 5];
    let ptr = data.as_ptr();
    let len = data.len();

    // === 规则1:偏移不能超出分配范围 ===
    // 允许指向"末尾后一个位置"(one past the end)
    // 但不能解引用
    let one_past_end = unsafe { ptr.add(len) };  // 合法
    // unsafe { *one_past_end };  // UB!超出范围

    // 用于循环终止条件
    let mut current = ptr;
    let end = one_past_end;
    print!("遍历: ");
    while current != end {
        // SAFETY: current 在 [ptr, end) 范围内
        print!("{} ", unsafe { *current });
        current = unsafe { current.add(1) };
    }
    println!();

    // === 规则2:偏移量不能导致地址溢出 ===
    // add(usize::MAX) 几乎一定溢出,是 UB
    // wrapping_add 不会 UB,但结果指针仍不可解引用

    // === 规则3:偏移必须在同一个分配对象内 ===
    let a = [1, 2, 3];
    let b = [4, 5, 6];
    let ptr_a = a.as_ptr();
    // 不能从 a 的指针偏移到 b 的内存
    // 即使它们在栈上可能相邻,这也是 UB

    // === 规则4:offset_from 的两个指针必须指向同一分配 ===
    let ptr_a_end = unsafe { ptr_a.add(a.len()) };
    // SAFETY: ptr_a 和 ptr_a_end 指向同一数组
    let dist = unsafe { ptr_a_end.offset_from(ptr_a) };
    println!("数组 a 长度: {}", dist);
}

用偏移实现数组操作 ​

rust
use std::ptr;

/// 用指针偏移实现数组的线性查找
fn ptr_find(data: &[i32], target: i32) -> Option<usize> {
    let base = data.as_ptr();
    let len = data.len();

    for i in 0..len {
        // SAFETY: i < len,ptr.add(i) 在数组范围内
        let val = unsafe { *base.add(i) };
        if val == target {
            return Some(i);
        }
    }
    None
}

/// 用指针偏移实现数组翻转
fn ptr_reverse(data: &mut [i32]) {
    if data.len() <= 1 {
        return;
    }

    let ptr = data.as_mut_ptr();
    let mut left = 0;
    let mut right = data.len() - 1;

    while left < right {
        // SAFETY: left < right < len,偏移在范围内
        unsafe {
            let l = ptr.add(left);
            let r = ptr.add(right);
            ptr::swap(l, r);
        }
        left += 1;
        right -= 1;
    }
}

/// 用指针偏移实现内存复制
fn ptr_copy(src: &[i32], dst: &mut [i32]) -> usize {
    let count = src.len().min(dst.len());

    if count == 0 {
        return 0;
    }

    let src_ptr = src.as_ptr();
    let dst_ptr = dst.as_mut_ptr();

    // SAFETY: count <= src.len() 且 count <= dst.len()
    // src 和 dst 是不同的切片,不重叠
    unsafe {
        ptr::copy_nonoverlapping(src_ptr, dst_ptr, count);
    }

    count
}

/// 用指针偏移实现二分查找
fn ptr_binary_search(data: &[i32], target: i32) -> Option<usize> {
    if data.is_empty() {
        return None;
    }

    let base = data.as_ptr();
    let mut low: usize = 0;
    let mut high: usize = data.len() - 1;

    while low <= high {
        let mid = low + (high - low) / 2;
        // SAFETY: mid 在 [low, high] 范围内,low < len,high < len
        let val = unsafe { *base.add(mid) };

        if val == target {
            return Some(mid);
        } else if val < target {
            low = mid + 1;
        } else {
            if mid == 0 { break; }
            high = mid - 1;
        }
    }
    None
}

fn main() {
    let mut data = vec![30, 10, 50, 20, 40];

    // 线性查找
    println!("=== 线性查找 ===");
    println!("查找 30: {:?}", ptr_find(&data, 30));
    println!("查找 40: {:?}", ptr_find(&data, 40));
    println!("查找 99: {:?}", ptr_find(&data, 99));

    // 翻转
    println!("\n=== 翻转 ===");
    println!("翻转前: {:?}", data);
    ptr_reverse(&mut data);
    println!("翻转后: {:?}", data);

    // 复制
    println!("\n=== 复制 ===");
    let src = [1, 2, 3, 4, 5];
    let mut dst = [0; 5];
    let count = ptr_copy(&src, &mut dst);
    println!("复制 {} 个: {:?}", count, dst);

    // 二分查找
    println!("\n=== 二分查找 ===");
    let sorted = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
    println!("查找 50: {:?}", ptr_binary_search(&sorted, 50));
    println!("查找 10: {:?}", ptr_binary_search(&sorted, 10));
    println!("查找 100: {:?}", ptr_binary_search(&sorted, 100));
    println!("查找 55: {:?}", ptr_binary_search(&sorted, 55));
}

结构体字段偏移 ​

rust
use std::mem;

#[repr(C)]
struct Record {
    id: u32,
    name: [u8; 16],
    score: f64,
    active: bool,
}

/// 计算结构体字段的偏移量
macro_rules! field_offset {
    ($type:ty, $field:ident) => {{
        // 创建一个空指针,计算字段地址
        let dummy = std::ptr::null::<$type>();
        // SAFETY: 不解引用空指针,只取字段地址
        let field_ptr = unsafe { &(*dummy).$field as *const _ };
        field_ptr as usize
    }};
}

fn main() {
    println!("=== Record 布局 ===");
    println!("大小: {} 字节", mem::size_of::<Record>());
    println!("对齐: {} 字节", mem::align_of::<Record>());

    // 字段偏移
    println!("\n=== 字段偏移 ===");
    println!("id:     偏移 {}", field_offset!(Record, id));
    println!("name:   偏移 {}", field_offset!(Record, name));
    println!("score:  偏移 {}", field_offset!(Record, score));
    println!("active: 偏移 {}", field_offset!(Record, active));

    // 通过偏移访问字段
    let record = Record {
        id: 42,
        name: *b"Alice\0\0\0\0\0\0\0\0\0\0\0",
        score: 95.5,
        active: true,
    };

    let base = &record as *const Record as *const u8;

    // 通过偏移读取 id
    let id_offset = field_offset!(Record, id);
    // SAFETY: base 有效,偏移在结构体范围内
    let id = unsafe { *(base.add(id_offset) as *const u32) };
    println!("\n通过偏移读取:");
    println!("  id = {}", id);

    // 通过偏移读取 score
    let score_offset = field_offset!(Record, score);
    let score = unsafe { *(base.add(score_offset) as *const f64) };
    println!("  score = {}", score);

    // 通过偏移读取 active
    let active_offset = field_offset!(Record, active);
    let active = unsafe { *(base.add(active_offset) as *const bool) };
    println!("  active = {}", active);

    // std::mem::offset_of!(Rust 1.77+ 稳定)
    println!("\n=== offset_of! 宏 ===");
    println!("id:     {}", mem::offset_of!(Record, id));
    println!("name:   {}", mem::offset_of!(Record, name));
    println!("score:  {}", mem::offset_of!(Record, score));
    println!("active: {}", mem::offset_of!(Record, active));
}

基本示例 ​

用指针偏移实现一个简单的内存池分配器:

rust
use std::alloc::{alloc, dealloc, Layout};
use std::ptr;

/// 固定大小的内存池
struct MemoryPool {
    base: *mut u8,           // 内存池起始地址
    item_size: usize,        // 每个槽位的大小
    capacity: usize,         // 总槽位数
    free_list: Vec<usize>,   // 空闲槽位索引
    layout: Layout,          // 分配布局
}

impl MemoryPool {
    fn new(item_size: usize, capacity: usize) -> Self {
        assert!(item_size > 0 && capacity > 0);

        // 对齐到 8 字节
        let aligned_size = (item_size + 7) & !7;
        let total = aligned_size * capacity;
        let layout = Layout::from_size_align(total, 8).unwrap();

        // SAFETY: layout 有效
        let base = unsafe { alloc(layout) };
        if base.is_null() {
            panic!("内存分配失败");
        }

        // 初始化空闲列表(所有槽位都空闲)
        let free_list: Vec<usize> = (0..capacity).rev().collect();

        MemoryPool {
            base,
            item_size: aligned_size,
            capacity,
            free_list,
            layout,
        }
    }

    /// 分配一个槽位,返回指针
    fn allocate(&mut self) -> Option<*mut u8> {
        let index = self.free_list.pop()?;
        // SAFETY: index < capacity,偏移在池范围内
        let ptr = unsafe { self.base.add(index * self.item_size) };
        Some(ptr)
    }

    /// 释放一个槽位
    fn deallocate(&mut self, ptr: *mut u8) -> bool {
        let offset = ptr as usize - self.base as usize;

        // 检查是否属于这个池
        if offset >= self.capacity * self.item_size {
            return false;
        }

        // 检查是否对齐到槽位边界
        if offset % self.item_size != 0 {
            return false;
        }

        let index = offset / self.item_size;
        self.free_list.push(index);
        true
    }

    /// 检查指针是否属于此池
    fn contains(&self, ptr: *const u8) -> bool {
        let addr = ptr as usize;
        let base = self.base as usize;
        let end = base + self.capacity * self.item_size;
        addr >= base && addr < end
    }

    /// 已分配的槽位数
    fn allocated_count(&self) -> usize {
        self.capacity - self.free_list.len()
    }

    /// 空闲槽位数
    fn free_count(&self) -> usize {
        self.free_list.len()
    }
}

impl Drop for MemoryPool {
    fn drop(&mut self) {
        // SAFETY: base 和 layout 在 new 中配对创建
        unsafe { dealloc(self.base, self.layout); }
    }
}

fn main() {
    // 创建一个 i32 大小的内存池,10 个槽位
    let mut pool = MemoryPool::new(std::mem::size_of::<i32>(), 10);
    println!("=== 内存池 ===");
    println!("空闲: {}, 已用: {}", pool.free_count(), pool.allocated_count());

    // 分配并写入值
    let mut ptrs = Vec::new();
    for i in 0..5 {
        if let Some(ptr) = pool.allocate() {
            // SAFETY: ptr 来自内存池,大小至少为 i32
            unsafe { (ptr as *mut i32).write(i * 100); }
            ptrs.push(ptr);
            println!("分配 [{}]: 值={}, 地址={:p}", i, i * 100, ptr);
        }
    }
    println!("空闲: {}, 已用: {}", pool.free_count(), pool.allocated_count());

    // 读取值
    println!("\n=== 读取 ===");
    for (i, &ptr) in ptrs.iter().enumerate() {
        // SAFETY: ptr 有效,内容为 i32
        let val = unsafe { (ptr as *const i32).read() };
        println!("  [{}] = {}, 属于池: {}", i, val, pool.contains(ptr));
    }

    // 释放部分
    println!("\n=== 释放 ===");
    pool.deallocate(ptrs[1]);
    pool.deallocate(ptrs[3]);
    println!("释放 [1] 和 [3]");
    println!("空闲: {}, 已用: {}", pool.free_count(), pool.allocated_count());

    // 重新分配(复用释放的槽位)
    println!("\n=== 复用 ===");
    if let Some(ptr) = pool.allocate() {
        // SAFETY: 新分配的槽位
        unsafe { (ptr as *mut i32).write(999); }
        println!("新分配: 值=999, 地址={:p}", ptr);
    }
    println!("空闲: {}, 已用: {}", pool.free_count(), pool.allocated_count());

    // 外部指针检查
    let external = 0x12345678 as *const u8;
    println!("\n外部指针属于池: {}", pool.contains(external));
}

常见问题 ​

问题一:add(1) 偏移多少字节?

取决于指针类型。*const i32 的 add(1) 偏移 4 字节(size_of::<i32>()),*const u8 的 add(1) 偏移 1 字节。偏移量 = n * size_of::<T>()。

问题二:偏移到"末尾后一个位置"合法吗?

合法。ptr.add(len) 对于长度为 len 的数组是合法的,这个指针可以用于比较(判断循环结束),但不能解引用。这与 C 语言的规则一致。

问题三:wrapping_add 和 add 有什么区别?

add 在偏移越界时是未定义行为(编译器假设它不会发生)。wrapping_add 在溢出时做模运算回绕,不是 UB,但结果指针仍然不一定可以解引用。wrapping_add 主要用于指针比较和哈希等场景。

问题四:可以从一个数组的指针偏移到另一个数组吗?

不行。即使两个数组在内存中相邻,从一个数组的指针偏移到另一个数组也是未定义行为。指针偏移只能在同一个分配对象(同一个数组、同一个 Box 等)内进行。

适用场景 ​

  • 数组/切片遍历:用指针代替索引遍历
  • 底层数据结构:环形缓冲区、内存池
  • FFI:访问 C 结构体的字段
  • 序列化/反序列化:按偏移读写二进制数据

注意事项 ​

  • 偏移以元素为单位,不是字节
  • 偏移不能超出分配对象的范围(可以到末尾后一位)
  • 不能跨分配对象偏移
  • byte_add / byte_sub 用于按字节偏移
  • wrapping_add 不会 UB 但结果指针可能无效
  • offset_from 要求两个指针指向同一分配对象
  • 使用 std::mem::offset_of! 获取结构体字段偏移

总结 ​

指针偏移计算通过 add、sub、offset 等方法对裸指针进行元素级别的偏移。偏移量以元素为单位(不是字节),*const T 的 add(n) 实际偏移 n * size_of::<T>() 字节。按字节偏移使用 byte_add / byte_sub。偏移必须在同一分配对象的范围内,可以指向末尾后一位(但不可解引用)。不能从一个数组偏移到另一个数组。wrapping_add 不会产生 UB 但结果指针仍需谨慎使用。offset_from 计算两个指针间的元素距离。std::mem::offset_of! 宏可以安全地获取 #[repr(C)] 结构体字段的偏移量。