rust引用

一、引用是什么

引用，又叫做借用。是一个指针类型。
引用是指向数据的指针，它允许我们以只读或可变的方式访问数据，而不获取数据的所有权。
编译器静态地保证了引用总是指向有效的对象。也就是说，当存在引用指向一个对象时，该对象不能被销毁

二、定义引用

在Rust中，使用&符号来创建引用。
（一）不可变引用
不可变引用，又叫共享引用。
不可变引用允许我们以只读方式访问数据，不允许修改数据。

语法格式

& type
1

示例：

fn main() {
     let mut x = 5;
     let y = &x;
     println!("x: {}", x);
     println!("y: {}", y);
}
1
2
3
4
5
6

可变变量x和不可变引用y，指向变量x的值。

（二）可变引用
可变引用允许我们以读写方式访问和修改数据。
语法格式

&mut type
1

示例：

let mut x = 5;
let y = &mut x;
*y += 1;
println!("x: {}", x);
println!("y: {}", y);
1
2
3
4
5

可变变量x和可变引用y，通过可变引用y修改了变量x的值。

引用的变量如果要变更，必须符合满足三个要求：
变量本身是可变的，也就是定义时必须添加 mut 关键字。
函数的参数也必须定义为可变的，也就是必须添加 &mut 关键字。
传递引用也必须是可变的，也就是传递参数时必须添加 &mut 关键字。
以上三个条件，任意一个不满足，都会报错。

三、使用引用

使用解引用操作符*来获取引用所指向的值

fn add_one(e: &mut i32) {
     *e+= 1;
}
fn main() {
     let mut i = 3;
     println!("before {}",i);
     add_one(&mut i);
     println!("after {}", i);
}
编译运行结果如下
before 3
after 4
1
2
3
4
5
6
7
8
9
10
11
12

let x = 5;
let y = &x;
assert_eq!(5, x);
assert_eq!(5, *y);
如果使用assert_eq!(5, y);，则会得到编译错误，不允许比较数字的引用与数字，因为它们是不同的类型。
1
2
3
4
5

四、悬垂引用

在具有指针的语言中，很容易通过释放内存时保留指向它的指针而错误地生成一个悬垂指针，悬垂指针也叫野指针，是其指向的内存可能已经被分配给其它人。它们就像失去悬挂物体的绳子，所以叫"悬垂指针"。
"悬垂引用"是一种悬垂指针。
在Rust语言里不允许出现悬垂引用
比如

fn main() {
     let reference_to_nothing = dangle();
}
fn dangle() -> &String {
     let s = String::from("hello");
     &s
}
1
2
3
4
5
6
7

编译错误。
因为 s 是在 dangle 函数内创建的，当 dangle 的代码执行完毕后，s 将被释放。返回的引用会指向一个无效的 String，这可不对！Rust不会允许我们这么做。
这里的解决方法是直接返回 String：

fn no_dangle() -> String {
     let s = String::from("hello");
     s
}
1
2
3
4

这样就没有任何错误了。所有权被移动出去，所以没有值被释放。

五、引用的规则

1.在同一时间点，要么 只能有一个可变引用，要么 只能有多个不可变引用。
2.引用必须总是有效的

一个引用的作用域从声明的地方开始一直持续到最后一次使用为止。
例如，

let mut s = String::from("hello");
let r1 = &s; // 没问题
let r2 = &s; // 没问题
println!("{} and {}", r1, r2); // 此位置之后r1和r2不再使用
let r3 = &mut s; // 没问题
println!("{}", r3);
1
2
3
4
5
6

不可变引用 r1 和 r2 的作用域在 println! 之后结束，这也是创建可变引用 r3 的地方。它们的作用域没有重叠，所以代码是可以编译的。

比如，下面例子是错误的，因为同一时间存在多个可变引用。

let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;
println!("{}, {}", r1, r2);
1
2
3
4

下面例子也是错误的，因为同一时间既存在可变引用，又存在不可变引用

let mut s = String::from("hello");
let r1 = &s; // 没问题
let r2 = &s; // 没问题
let r3 = &mut s; // 大问题
println!("{}, {}, and {}", r1, r2, r3);
1
2
3
4
5