Rust 中的 & 和 ref_rust ref

1. & 和 ref 都是用来定义指针的

废话少说，先看代码：

fn main() {
    let mut a: i32 = 111;

    let b = &a;
    println!("{}", *b); //111

    let ref c = a;
    println!("{}", *c); //111
}
1
2
3
4
5
6
7
8
9

而这结果一样，都是在声明一个指针。区别在那里？& 放在等号的右边， ref 放在等好的左边。

在看个例子，看看如何用指针修改变量：

fn main() {
    let mut a: i32 = 111;

    let b = &mut a; // 指针 b 本身是不可以修改的，但它指向的内容是可以修改的。
    *b = 222;
    println!("{}", a); // 222

    let ref mut c = a; // 指针 c 本身是不可以修改的，但它指向的内容是可以修改的。
    *c = 333;
    println!("{}", a); //333
}
1
2
3
4
5
6
7
8
9
10
11

在代码行里，二者没有任何区别。但是，为什么弄出两个来呢？

2. 只能用 & 定义指针的地方

看一段代码：

fn foo(x: &mut i32) {
    *x = 999;
}
fn main() {
    let mut a: i32 = 111;
    foo(&mut a);
    println!("{}", a); // 999
}
1
2
3
4
5
6
7
8

在函数传参的时候用到了 & 来表示传入参数栈的是一个可修改变量的地址。

下面我们修改一下，改成下面的代码：

fn foo(ref mut x: i32) {
    *x = 999;
}
fn main() {
    let mut a: i32 = 111;
    foo(a);
    println!("{}", a); // 111
}
1
2
3
4
5
6
7
8

foo(a) 的调用语义是说，要把 a 的值复制到栈空间，因此，fn foo(ref mut x: i32) 中参数 x 引用的是栈上的数据。也就是说，不管函数的参数 x 如何声明，foo(a) 这种形式传入参数 a，都不可能修改变量 a 的值。我觉得这个规定是合理的，比 C++ 的引用的语义声明简单、合理多了。

我们再修改一下：

fn foo(ref x: &mut i32) {
    **x = 999;
}
fn main() {
    let mut a: i32 = 111;
    foo(&mut a);
    println!("{}", a); // 999
}
1
2
3
4
5
6
7
8

这次又成功了。但是这个 **x 你不觉得麻烦吧？因此，在函数参数声明中，一般只用 & 来传入变量的地址。

3. 只能用 ref 定义指针的地方

看下面的代码：

fn main() {
    let s = Some(String::from("Hello!"));
    match s {
        Some(t) => println!("t = {}", t),
        _ => {}
    }
    println!("s = {}", s.unwrap());
}
1
2
3
4
5
6
7
8

这个是无法编译的。因为 match s 语句中，已经把 s 的所有权给转移了，导致最后一条语句无法执行。编译提示如下：

编译期建议在模式匹配中把变量 t 改成 ref t，也就是说把 t 声明成指针即可解决问题。修改后代码如下：

fn main() {
    let s = Some(String::from("Hello!"));
    match s {
        Some(ref t) => println!("t = {}", t),
        _ => {}
    }
    println!("s = {}", s.unwrap());
}
1
2
3
4
5
6
7
8

因为在模式匹配代码块中，我们没有机会声明变量类型，只能用 ref 表示变量 t 是个指针。

我试了一下，不用 ref 的话，还有一个变通的方法，就是把 match s 改成 match &s。代码如下：

fn main() {
    let s = Some(String::from("Hello!"));
    match &s {
        Some(t) => println!("t = {}", t),
        _ => {}
    }
    println!("s = {}", s.unwrap());
}
1
2
3
4
5
6
7
8

这个时候 t 前面加不加 ref 结果都一样。因为 match 只是借用 s，所以不会影响 s 的生命周期。

4. 更多的试验

下面给出了一组代码，我们看看那些是合法的，那些是非法的。

fn main() {
    let v = 123;

    let x: &i32 = &v; 					// OK!
    let x: &i32 = &(123 + 456); 		// OK!
    if let Some(x:&i32) = Some(&123); 	// Error！

    let ref x: i32 = v;					// OK!
    let ref x: i32 = 123 + 456;			// OK!
    if let Some(ref x) = Some(123) {}	// OK!
}
1
2
3
4
5
6
7
8
9
10
11

5. 指针变量的解引用

看下面代码，道理我不多讲了，rust 会自动解多层嵌套引用，这个太方便了。

fn main() {
    let a: &i32 = &123;
    let b: &&i32 = &a;
    let c: &&&i32 = &b;

    println!("a = {}, b = {}, c = {}", a, b, c);
    println!("*a = {}, **b = {}, ***c = {}", *a, **b, ***c);
}

/* output
a = 123, b = 123, c = 123
*a = 123, **b = 123, ***c = 123
*/
1
2
3
4
5
6
7
8
9
10
11
12
13