Rust语言从入门到精通系列 - Borrow和BorrowMut特征

Borrow#

Borrow 方法用于借用一个值的不可变引用。这个方法的语法如下：

1
fn borrow(&self) -> &T

其中，&self表示当前值的引用，&T表示返回的借用值的类型。下面是一个使用 borrow 方法的示例：

1
fn main() {
2
    let v = vec![1, 2, 3];
3
    let r = v.borrow();
4
    println!("{:?}", r);
5
}

这个示例中，我们创建了一个包含三个元素的向量。然后，我们使用 borrow 方法来借用这个向量的不可变引用，并将其绑定到变量 r 上。最后，我们打印出 r 的值。输出结果为[1, 2, 3]。

BorrowMut#

BorrowMut 方法用于借用一个值的可变引用。这个方法的语法如下：

1
fn borrow_mut(&mut self) -> &mut T

其中，&mut self表示当前值的可变引用，&mut T表示返回的借用值的类型。下面是一个使用 borrow_mut 方法的示例：

1
fn main() {
2
    let mut v = vec![1, 2, 3];
3
    v.push(4);
4
    println!("{:?}", v);
5
}

这个示例中，我们创建了一个包含三个元素的向量，并将其绑定到变量 v 上。然后，我们使用 borrow_mut 方法来借用这个向量的可变引用，并将其绑定到变量 r 上。接着，我们使用 r 的 push 方法向向量中添加一个元素。最后，我们打印出 v 的值。输出结果为[1, 2, 3, 4]。

借用一个字符串的不可变引用#

1
fn main() {
2
    let s = String::from("hello");
3
    let r = s.borrow();
4
    println!("{}", r);
5
}

这个示例中，我们创建了一个包含字符串”hello”的字符串。然后，我们使用 borrow 方法来借用这个字符串的不可变引用，并将其绑定到变量 r 上。最后，我们打印出 r 的值。输出结果为hello。

借用一个字符串的可变引用#

1
fn main() {
2
    let mut s = String::from("hello");
3
    s.push_str(", world!");
4
    println!("{}", s);
5
}

这个示例中，我们创建了一个包含字符串”hello”的字符串，并将其绑定到变量 s 上。然后，我们使用 borrow_mut 方法来借用这个字符串的可变引用，并将其绑定到变量 r 上。接着，我们使用 r 的 push_str 方法向字符串中添加一个后缀。最后，我们打印出 s 的值。输出结果为hello, world!。

借用一个数组的不可变引用#

1
fn main() {
2
    let a = [1, 2, 3];
3
    let r = a.borrow();
4
    println!("{:?}", r);
5
}

这个示例中，我们创建了一个包含三个元素的数组。然后，我们使用 borrow 方法来借用这个数组的不可变引用，并将其绑定到变量 r 上。最后，我们打印出 r 的值。输出结果为[1, 2, 3]。

借用一个数组的可变引用#

1
fn main() {
2
    let mut a = [1, 2, 3];
3
    {
4
        let r = a.borrow_mut();
5
        r[1] = 4;
6
    }
7
    println!("{:?}", a);
8
}

这个示例中，我们创建了一个包含三个元素的数组，并将其绑定到变量 a 上。然后，我们使用 borrow_mut 方法来借用这个数组的可变引用，并将其绑定到变量 r 上。接着，我们使用 r 来修改数组中的一个元素。最后，我们打印出 a 的值。输出结果为[1, 4, 3]。

借用一个结构体的不可变引用#

1
#[derive(Debug)]
2
struct Point {
3
    x: i32,
4
    y: i32,
5
}
6

7
fn main() {
8
    let p = Point { x: 1, y: 2 };
9
    let r = &p;
10
    println!("{:?}", r);
11
}

这个示例中，我们创建了一个包含 x 和 y 两个字段的结构体 Point，并将其绑定到变量 p 上。然后，我们使用&符号来借用这个结构体的不可变引用，并将其绑定到变量 r 上。最后，我们打印出 r 的值。输出结果为Point { x: 1, y: 2 }。

借用一个结构体的可变引用#

1
#[derive(Debug)]
2
struct Point {
3
    x: i32,
4
    y: i32,
5
}
6

7
fn main() {
8
    let mut p = Point { x: 1, y: 2 };
9
    {
10
        let r = &mut p;
11
        r.x = 3;
12
    }
13
    println!("{:?}", p);
14
}

这个示例中，我们创建了一个包含 x 和 y 两个字段的结构体 Point，并将其绑定到变量 p 上。然后，我们使用&mut 符号来借用这个结构体的可变引用，并将其绑定到变量 r 上。接着，我们使用 r 来修改结构体中的一个字段。最后，我们打印出 p 的值。输出结果为Point { x: 3, y: 2 }。

借用一个值的引用#

1
fn main() {
2
    let v1 = vec![1, 2, 3];
3
    let v2 = vec![4, 5, 6];
4
    let r = &v1;
5
    println!("{:?}", r);
6
}

这个示例中，我们创建了两个包含三个元素的向量 v1 和 v2。然后，我们使用&符号来借用 v1 的引用，并将其绑定到变量 r 上。最后，我们打印出 r 的值。输出结果为[1, 2, 3]。

借用一个值的可变引用的引用#

1
fn main() {
2
    let mut v1 = vec![1, 2, 3];
3
    let v2 = vec![4, 5, 6];
4
    {
5
        let r = &mut &mut v1;
6
        (*r).push(4);
7
    }
8
    println!("{:?}", v1);
9
}

这个示例中，我们创建了两个包含三个元素的向量 v1 和 v2，并将 v1 绑定到变量 v1 上。然后，我们使用&mut 符号来借用 v1 的可变引用的可变引用，并将其绑定到变量 r 上。接着，我们使用*r 来访问 v1，并向其添加一个元素。最后，我们打印出 v1 的值。输出结果为[1, 2, 3, 4]。

借用一个值的不可变引用的可变引用#

1
fn main() {
2
    let mut v1 = vec![1, 2, 3];
3
    let v2 = vec![4, 5, 6];
4
    let r = &mut v1;
5
    *r = vec![7, 8, 9];
6
    println!("{:?}", v1);
7
}

这个示例中，我们创建了两个包含三个元素的向量 v1 和 v2。然后，我们使用&符号来借用 v1 的不可变引用的可变引用，并将其绑定到变量 r 上。接着，我们使用**r 来访问 v1，并将其替换为一个新的向量。最后，我们打印出 v1 的值。输出结果为[7, 8, 9]。

借用一个值的可变引用的不可变引用#

1
fn main() {
2
    let mut v1 = vec![1, 2, 3];
3
    let v2 = vec![4, 5, 6];
4
    v1.push(4);
5
    println!("{:?}", v1);
6
}

这个示例中，我们创建了两个包含三个元素的向量 v1 和 v2，并将 v1 绑定到变量 v1 上。然后，我们使用 borrow_mut 方法来借用 v1 的可变引用，并将其绑定到变量 r 上。接着，我们使用 r 的 push 方法向 v1 中添加一个元素。最后，我们打印出 v1 的值。输出结果为[1, 2, 3, 4]。