如果每次都发生所有权的转移，程序的编写就会变得异常复杂。因此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 可以顺利借用到可变引用。
对于这种编译器优化行为，Rust 专门起了一个名字 —— Non-Lexical Lifetimes(NLL)，专门用于找到某个引用在作用域(})结束前就不再被使用的代码位置。
