原文链接：https://doc.rust-lang.org/nomicon/working-with-unsafe.html

编写非安全代码

Rust通常要求我们明确限制非安全Rust代码的作用域。可是，现实情况其实要更复杂一些。举个例子，看一下下面的代码：

  1. fn index(idx: usize, arr: &[u8]) -> Option<u8> {
  2.     if idx < arr.len() {
  3.         unsafe {
  4.             Some(*arr.get_unchecked(idx))
  5.         }
  6.     } else {
  7.         None
  8.     }
  9. }

这个函数是安全和正确的。我们检查了索引值有没有越界。如果没有，就从数组中用不安全的方式取出对应的值。然而，哪怕是这么简单的一个函数，unsafe代码块的范围也不是绝对明确的。想象一下，如果把 <改成 <=：

  1. fn index(idx: usize, arr: &[u8]) -> Option<u8> {
  2.     if idx <= arr.len() {
  3.         unsafe {
  4.             Some(*arr.get_unchecked(idx))
  5.         }
  6.     } else {
  7.         None
  8.     }
  9. }

这段程序就有潜在的问题了，但我们其实只修改了安全代码的部分。这是安全机制的一个根本性问题：非本地性。意思是，非安全代码的稳定性其实依赖于另一些“安全”代码的状态。

是否进入非安全代码块，并不受其他部分代码正确性的影响，从这个角度看安全机制是模块化的。比如，是否对一个slice进行不安全索引，不受slice是不是null或者是不是包含未初始化的内存这些事情的影响。但是，由于程序本身是有状态的，非安全操作的结果实际依赖于其他部分的状态，从这个角度看安全机制又是非模块化的。

在处理持久化状态时，非本地性带来的问题就更加明显了。看一下Vec的一个简单实现：

  1. use std::ptr;
  3. // 注意：这个定义十分简单。参考实现Vec的章节
  4. pub struct Vec<T> {
  5.     ptr: *mut T,
  6.     len: usize,
  7.     cap: usize,
  8. }
  10. // 注意：这个实现未考虑大小为0的类型。参考实现Vec的章节
  11. impl<T> Vec<T> {
  12.     pub fn push(&mut self, elem: T) {
  13.         if self.len == self.cap {
  14.             // 与例子本身无关
  15.             self.reallocate();
  16.         }
  17.         unsafe {
  18.             ptr::write(self.ptr.offset(self.len as isize), elem);
  19.             self.len += 1;
  20.         }
  21.     }
  22. }

这段代码很简单，便于审查和修改。现在考虑给它添加一个新的方法：

  1. fn make_room(&mut self) {
  2.     // 增加容量
  3.     self.cap += 1;
  4. }

这段代码是100%的安全Rust但是彻底的不稳定。改变容量违反了Vec的不变性（cap表示分配给Vec的空间大小）。Vec的其他部分并不会保护它，我们只能信任它的值是正确的，因为本来没有修改它的方法。

因为代码逻辑依赖于struct的某个成员的不变性，那段unsafe的代码不仅仅污染了它所在的函数，它还污染了整个module。一般来说，只有在一个私有的module里非安全代码才可能是真正安全的。

上面的改动其实是可以正常工作的。make_room方法并不会导致Vec的问题，因为我们没有设置它为public。只有定义这个方法的module可以调用它。同时，make_room直接访问了Vec的私有成员，所以它也只能在Vec所在的module内使用。

这允许我们基于一些复杂的不变性写一些绝对安全的抽象。在考虑安全Rust和非安全Rust的关系时，这一点非常重要。

我们已经了解了非安全代码必须信任一部分安全代码，但是不应该信任所有的安全代码。出于相似的原因，私有成员的限制对于非安全代码很重要：我们不需要无条件信任世界上所有的安全代码并且任由他们搞乱我们的可信任状态。

安全机制万岁！