Rust安全编码是否应避免指针算术？有哪些替代实现方式？

问题描述 #

我了解到在Rust中可通过pointer.offset()函数实现指针算术，但必须在unsafe code中执行，示例代码如下：

fn main() { 
    let buf: [u32; 5] = [1, 2, 3, 4, 5]; 
    let mut ptr1: *const u32 = buf.as_ptr(); 
    unsafe { 
        let ptr2: *const u32 = buf.as_ptr().offset(buf.len() as isize); 
        while ptr1 < ptr2 { 
            println!("Address {:?} | Value {}", ptr1, *ptr1); 
            ptr1 = ptr1.offset(1); 
        } 
    } 
}

若想进行Rust安全编码，是否应完全避免使用指针算术，转而采用数组索引这类方式？还有其他可行方案吗？

回答 #

首先明确：不是必须完全避免指针算术，但在绝大多数日常开发场景下，绝对应该优先选择安全的替代方案——毕竟Rust的核心优势就是通过类型系统和借用检查器帮你规避内存安全问题，而手动指针算术完全依赖开发者自己把控所有安全细节，很容易引入越界、悬垂指针这类难以排查的bug。

下面是几种常见的安全替代方案：

• 使用迭代器遍历（最推荐）
  你示例中的代码完全可以用迭代器重写成纯安全代码，效果完全一致，还不需要手动管理指针：

  fn main() {
      let buf: [u32; 5] = [1, 2, 3, 4, 5];
      for &val in buf.iter() {
          // 通过有效引用转换指针是安全操作
          let addr = &val as *const u32;
          println!("Address {:?} | Value {}", addr, val);
      }
  }
  

  如果需要同时获取索引位置，还可以搭配enumerate()方法：

  fn main() {
      let buf: [u32; 5] = [1, 2, 3, 4, 5];
      for (idx, &val) in buf.iter().enumerate() {
          let addr = &val as *const u32;
          println!("Index {} | Address {:?} | Value {}", idx, addr, val);
      }
  }
  

• 使用数组/切片索引
  如果你需要手动控制遍历的位置，切片索引是完全安全的，Rust会在debug模式下自动检查越界，避免非法内存访问：

  fn main() {
      let buf: [u32; 5] = [1, 2, 3, 4, 5];
      for i in 0..buf.len() {
          let val = buf[i];
          let addr = &buf[i] as *const u32;
          println!("Address {:?} | Value {}", addr, val);
      }
  }
  

• 使用切片的安全方法处理内存分段
  如果你的场景是需要把连续内存块分成多个部分，可以用split_at、chunks、windows这类内置安全方法，它们会帮你保证生成的切片始终是有效的，无需手动操作指针：

  fn main() {
      let buf: [u32; 5] = [1, 2, 3, 4, 5];
      // 分成前2个和后3个元素的切片
      let (first_part, second_part) = buf.split_at(2);
      println!("First part: {:?}", first_part);
      println!("Second part: {:?}", second_part);
  
      // 按每2个元素为一组遍历
      for chunk in buf.chunks(2) {
          println!("Chunk: {:?}", chunk);
      }
  }
  

当然，也存在必须使用指针算术的场景——比如底层性能优化、和C语言交互、实现某些无标准库的底层组件等。这时候你必须用unsafe代码，但一定要严格遵循Rust的unsafe安全准则：

• 确保指针始终指向有效的、未释放的内存
• 允许指向数组末尾的下一个位置作为哨兵，但绝对不能解引用它
• 避免数据竞争，确保指针的访问符合Rust的内存模型

你的示例代码其实是符合unsafe安全规范的：ptr2指向数组末尾的下一个位置（合法的哨兵指针），循环中ptr1始终在有效内存范围内，解引用是安全的。但这种写法完全可以被迭代器替代，没必要手动写指针算术。

内容的提问来源于stack exchange，提问作者Habebit