rust引用和借用的如何使用小结

引用和借用如果每次都发生所有权的转移，程序的编写就会变得异常复杂。因此rust和其它编程语言类似，提供了引用的方式来操作。获取变量的引用，称为借用。类似于你借

引用和借用

如果每次都发生所有权的转移，程序的编写就会变得异常复杂。因此rust和其它编程语言类似，提供了引用的方式来操作。获取变量的引用，称为借用。类似于你借别人的东西来使用，但是这个东西的所有者不是你。引用不会发生所有权的转移。

引用的使用

在rust中，引用的语法非常简单。通过&来取引用，通过*来解引用。例如：

fn main() {
    let s1: String = "Hello".to_string();
    let s2: &String = &s1;       // s2引用s1

    println!("{s1}");
    println!("{s2}");
}

这段代码可以正常运行，因为s2引用的s1，不会发生所有权的转移。再来看一个例子，通过引用来传递函数参数。

fn main() {
    let s = "Hello".to_string();
    let len = calculate_length(&s);     // 引用

    println!("{s}");
    println!("{len}");
}


fn calculate_length(s: &String) -> usize {
    s.len()
}

在calculate_length中，s是一个引用，它不具备所有权，因此在函数调用结束的时候，s的作用域虽然结束了，但是不会调用drop。

可变引用与不可变引用

在刚才的例子中，只是获取了字符串的长度，相当于我们读取了变量。在rust中，引用默认也是不可变的，如果需要通过引用修改变量，那么必须使用可变引用。可变引用和可变变量一样，都是通过关键字mut来实现的。例如：

fn main() {
    let mut s = String::from("hello");
    change(&mut s);     // 可变引用
    println!("{s}");
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

这段代码输出hello, world，可见我们通过可变引用修改了s的值，但是在这个过程中并没有涉及所有权的转移。

事实上，事情并没有这么简单。可变引用并不是可以随心所欲的被使用。它有一个很大的限制，“同一作用域，一个变量只能有一个可变引用”。例如：

fn main() {
    let mut s = String::from("hello");

    let r1 = &mut s;
    let r2 = &mut s;     // 同一作用域，无法创建两个可变引用。

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

两个可变引用，可能会出现“同时写入”这种情况，导致内存不安全的情形发生。如果在不同的作用域，可以有多个可变引用，但是它们不能同时被拥有。例如：

fn main() {
    let mut s = String::from("hello");

    {
        let r1 = &mut s;
        println!("{r1}");
    } // r1 在这里离开了作用域，所以我们完全可以创建一个新的引用

    let r2 = &mut s;
    println!("{r2}");
}

同时rust也不允许同时存在可变引用和不可变引用。因为不可变引用可能会因可变引用变得失效。下面以一段C++代码来说明这一点。

#include<vector>
#include<string>
#include<iostream>

using namespace std;

int main() {
    
    // 可读引用因可变引用而变得失效
    vector<string> vs;
    vs.push_back("hello");

    auto & elem = vs[0];

    vs.push_back("world");      // push_back会导致vs指向的整段内存被重新分配并移到了另一个地址，原本迭代器里面的引用就全部变成悬垂指针了。

    cout << vs[0] << endl;
    cout << elem << endl;       // 试图使用悬垂指针
    
    return 0;
}

这段代码执行之后，结果如下所示：

hello
Segmentation fault (core dumped)

很明显，这里的段错误正是由于试图使用悬垂指针引起的。而rust特殊的可变引用和不可变引用机制避免了这种错误的发生。例如：

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");

    &s
}   // 返回s的引用，函数结束，s移出作用域，调用drop函数清理内存，那么返回的引用将会变成悬垂引用，从而引发错误。

这段rust代码无法编译通过，从而避免了像上面C++代码那样的运行时错误。

正如Rust 程序设计语言中所言

这一限制以一种非常小心谨慎的方式允许可变性，防止同一时间对同一数据存在多个可变引用。新 Rustacean 们经常难以适应这一点，因为大部分语言中变量任何时候都是可变的。这个限制的好处是 Rust 可以在编译时就避免数据竞争。数据竞争（data race）类似于竞态条件，它可由这三个行为造成：

两个或更多指针同时访问同一数据。
至少有一个指针被用来写入数据。
没有同步数据访问的机制。

Rust 的编译器一直在优化，早期的时候，引用的作用域跟变量作用域是一致的，这对日常使用带来了很大的困扰，你必须非常小心的去安排可变、不可变变量的借用，免得无法通过编译，例如以下代码：

fn main() {
   let mut s = String::from("hello");

    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);
    // 新编译器中，r1,r2作用域在这里结束

    let r3 = &mut s;
    println!("{}", r3);
} // 老编译器中，r1、r2、r3作用域在这里结束
  // 新编译器中，r3作用域在这里结束

在老版本的编译器中（Rust 1.31 前），将会报错，因为 r1 和 r2 的作用域在花括号 } 处结束，那么 r3 的借用就会触发无法同时借用可变和不可变的规则。但是在新的编译器中，该代码将顺利通过，因为引用作用域的结束位置从花括号变成最后一次使用的位置，因此 r1 借用和 r2 借用在 println! 后，就结束了，此时 r3 可以顺利借用到可变引用。