原始指针的数据消失了

Question

请考虑以下代码:

struct Person {
  mate: Option<*const Person>,
  siblings: Vec<i32>,
}

impl Person {
  fn meets(&mut self, mate: &mut Person) {
    self.mate = Some(mate);
    mate.mate = Some(self); 
  }
}

struct Bar {
  person: Person,
}

impl Bar {
  fn addr(&self) {
    unsafe {
      println!("\n`bob.siblings.len()`: {}, `bob.susan.siblings.len()`: {}", 
        self.person.siblings.len(), (*self.person.mate.unwrap()).siblings.len());

      println!("\n but wait -> `bob.susan.bob.siblings.len()`: {} ??", 
        (*(*self.person.mate.unwrap()).mate.unwrap()).siblings.len());

      println!("\nthis is `bob.susan.bob's address`: {:p} => same address inside bar ???", 
        (*self.person.mate.unwrap()).mate.unwrap());
    }
  }
}

fn main() {
  let mut bob = Person {
    mate: None,
    siblings: {
      let mut stuff: Vec<i32> = Vec::new();
      unsafe {
        stuff.set_len(2);
      }
      stuff
    }
  };

  let mut susan = Person { 
    mate: None, 
    siblings: {
      let mut stuff: Vec<i32> = Vec::new();
      unsafe {
        stuff.set_len(4);
      }
      stuff
    } 
  };

  bob.meets(&mut susan);

  println!("\nbob has {} `siblings` before entering the `bar`.", bob.siblings.len());
  println!("\nthis is bob's address: {:p}", &bob);
  let bar = Bar { person: bob };
  bar.addr();
}

结果:

bob has 2 `siblings` before entering the `bar`.

this is bob's address: 0x7fff556ab470

`bob.siblings.len()`: 2, `bob.susan.siblings.len()`: 4

 but wait -> `bob.susan.bob.siblings.len()`: 0 ??

this is `bob.susan.bob's address`: 0x7fff556ab470 => same address inside bar ???

---

我的问题是,bob.siblings去哪儿了？即使我打电话bob.siblings通过susan(bob.mate.mate.siblings- > bob.susan.bob.siblings),结果应该不一样吗？

我如何打电话bob.susan.bob.siblings并得到与我打电话相同的结果bob.siblings？

锈版: rustc 1.0.0-nightly (270a677d4 2015-03-07) (built 2015-03-07)

Answer 1

这将是Rust帮助防止的一个很​​好的例子,但是你故意关闭安全检查,现在我们回到C.检查这一行:

let bar = Bar { person: bob };

这条线移动存储在数据bob进入bar.这意味着指针已失效,您不能信任任何值.我们之后再添加:

println!("\nthis is bob's address: {:p}", &bob);
let bar = Bar { person: bob };
println!("\nthis is the bar's address: {:p}", &bar);
println!("\nthis is bob's new address: {:p}", &bar.person);

// this is bob's address:     0x7fffe10518c0
// this is the bar's address: 0x7fffe10517d0
// this is bob's new address: 0x7fffe10517d0

你现在正处于一个受伤的世界,因为你试图争论哪些指针是正确的,哪些指针不正确!

解决这个问题的一种方法是不动bob.相反,请参考:

struct Bar<'a> {
  person: &'a Person,
}
// ...
let bar = Bar { person: &bob };

另一个是将它移动到以下meets 后调用bar:

let mut bar = Bar { person: bob };
bar.person.meets(&mut susan);

另一种是Box(或使用Arena)数据.然后数据没有在堆栈上分配,因此移动时值的地址不会改变:

struct Bar {
    person: Box<Person>,
}
// ...
let mut bob = Box::new(Person { });
let mut susan = Box::new(Person { });