引用与借用：深入解析与实践应用

引用与借用

• 引用是一种数据类型

  
  



• & 符号就是引用

  
  
  
  
  • 允许使用值但不获取其所有权
  
  
  
  



• 解引用（dereferencing）

  
  
  
  
  • 解引用运算符 *
  
  
  
  

fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1); // &s1 创建了一个指向 s1 的引用，但不拥有s1

println!("The length of '{}' is {}.", s1, len);
}
fn calculate_length(s: &String) -> usize { //参数为&String，不是String
s.len()
} // s 离开了作用域。但因为它并不拥有引用值的所有权，所以什么也不会发生


• s 为 s1 的引用，s 指向 s1 （指针？

  

  
  

借用（borrowing）

• 把引用作为函数参数的行为叫做借用

  
  



• 默认不允许修改引用的值

  fn main() {
let s = String::from("hello");
change(&s);
}
fn change(some_string: &String) {
some_string.push_str(", world");
}


  该代码不能编译

  
  

可变引用

• &mut string就为一个可变引用类型

  fn main() {
let mut s = String::from("hello");
change(&mut s);
}
fn change(some_string: &mut String) {
some_string.push_str(", world");
}


  该代码可以正常编译

  
  



• 限制：在同一时间，对于某一特定的数据，只能有一个可变引用

  
  
  
  
  • 尝试创建两个可变引用的代码将会失败
  
  

  let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;

println!("{}, {}", r1, r2);


  该代码不能编译

  
  



• 这个限制的好处是 Rust 可以在编译时就避免数据竞争（出现数据竞争的情况时，rust在编译时就会报错

  
  
  
  
  • 数据竞争（data race）类似于竞态条件，它可由这三个行为造成：
    
    
    
    • 两个或更多指针同时访问同一数据
    
    
    • 至少有一个指针被用来写入数据
    
    
    • 没有同步数据访问的机制
    
    
    
    
  
  
  
  



• 可以创建新的作用域（通过大括号），以允许非同时拥有多个可变引用

  let mut s = String::from("hello");
{
let r1 = &mut s;
} // r1 在这里离开了作用域，所以可以创建一个新的引用 r2

let r2 = &mut s;

  




• 另一个限制：不可以同时有一个可变引用与一个不可变引用

  
  
  
  
  • 但可以有多个不可变引用
  
  

  let mut s = String::from("hello");
let r1 = &s; // 不可变引用
let r2 = &s; // 不可变引用
let r3 = &mut s; // 可变引用，不可以

println!("{}, {}, and {}", r1, r2, r3);


  该代码不可以编译

  
  

悬垂引用（Dangling References）

• 悬垂指针（dangling pointer），即一个指针引用了内存的某个地址，但这块内存可能已经事发并分配给其他人使用了

  
  



• 在 Rust 中编译器可以确保引用永远也不会变成悬垂状态

  
  
  
  
  • 当你拥有一些数据的引用，编译器确保数据不会在其引用之前离开作用域。
  
  

  fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String {
let s = String::from("hello"); // s 在离开函数（离开作用域）后，就失效了
&s //但对 s 的引用 &s 作为返回值返回了
//即对 s 的引用 &s 就指向了一个被释放的内存地址
}


  该代码不可以编译

  
  

引用的规则（总结

• 在任意给定时间，要么 只能有一个可变引用，要么 只能有多个不可变引用


• 引用必须一直是有效的