Rust语言从入门到精通系列 - 所有权

所有权#

在Rust中，每个值都有一个所有者。所有者是一个变量，它拥有该值并负责释放该值。当所有者超出范围时，它们拥有的值将被释放。这种方式确保了内存的安全和高效使用。 让我们看一个简单的例子：

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

在这个例子中，我们创建了一个字符串hello并将其赋值给变量s。变量s是该字符串的所有者。当程序执行到println!宏时，它打印字符串s的值。当程序执行完毕时，变量s超出了其作用域，该值将被自动释放。

1
fn main() {
2
    let s1 = String::from("hello");
3
    let s2 = s1;
4
    println!("{}", s2);
5
}
6
//     输出内容：
7
// hello

1
fn main() {
2
    let s1 = String::from("hello");
3
    let s2 = s1;
4
    println!("{}", s1);
5
}
6

7
//    编译错误：
8
// error[E0382]: borrow of moved value: `s1`
9
//  --> src/main.rs:9:20
10
//   |
11
// 7 |     let s1 = String::from("hello");
12
//   |         -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
13
// 8 |     let s2 = s1;
14
//   |              -- value moved here
15
// 9 |     println!("{}", s1);
16
//   |                    ^^ value borrowed here after move
17
//   |
18
//   = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
19
// help: consider cloning the value if the performance cost is acceptable
20
//   |
21
// 8 |     let s2 = s1.clone();
22
//   |                ++++++++
23

24
// For more information about this error, try `rustc --explain E0382`.

1
fn main() {
2
    let s1 = String::from("hello");
3
    let len = calculate_length(&s1);
4
    println!("The length of '{}' is {}.", s1, len);
5
}
6

7
fn calculate_length(s: &String) -> usize {
8
    s.len()
9
}
10
//     输出内容：
11
//    The length of 'hello' is 5.

1
fn main() {
2
    let s1 = String::from("hello");
3
    let s2 = &s1;
4
    println!("{}", &s1);
5
}
6
//     输出内容：
7
// hello

可变借用#

在Rust中，我们可以通过可变借用来允许修改借用的值。例如：

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

7
fn change(s: &mut String) {
8
    s.push_str(", world");
9
}
10
//     输出内容：
11
//    hello, world

在这个例子中，我们创建了一个可变字符串hello并将其赋值给变量s。然后，我们通过将变量s的可变引用传递给函数change来可变借用该字符串的所有权。该函数将字符串world添加到字符串s的末尾。当程序执行到println!宏时，它打印字符串s的值，该值现在是hello, world。当程序执行完毕时，变量`s 超出了其作用域，但由于我们只是可变借用了它，所以该值并没有被释放。 需要注意的是，在可变借用时，我们需要使用可变引用符号&mut来指示我们要可变借用该值的所有权，而不是转移所有权。例如：

1
fn main() {
2
    let mut s = String::from("hello");
3
    let s_ref = &mut s;
4
    println!("{}", s_ref);
5
}
6
//     输出内容：
7
// hello

在这个例子中，我们通过可变借用s_ref来访问和打印变量s的值。注意：当可变借用s_ref仍然有效时，不能同时通过s来访问该值，因为Rust不允许可变借用和其它借用同时存在。如果需要在可变借用之后再次使用s，可以让可变借用的作用域先结束：

1
fn main() {
2
    let mut s = String::from("hello");
3
    {
4
        let s_ref = &mut s;
5
        s_ref.push_str(", world");
6
    } // s_ref 在这里离开作用域，可变借用结束
7
    println!("{}", s); // 现在可以正常使用 s
8
}
9
//     输出内容：
10
// hello, world

所有权和函数#

在Rust中，函数可以接受值的所有权、借用值的所有权或返回值的所有权。例如：

1
fn main() {
2
    let s = String::from("hello");
3
    let (s, len) = calculate_length(s);
4
    println!("The length of '{}' is {}.", s, len);
5
}
6

7
fn calculate_length(s: String) -> (String, usize) {
8
    let len = s.len();
9
    (s, len)
10
}
11
//     输出内容：
12
//    The length of 'hello' is 5.

在这个例子中，我们创建了一个字符串hello并将其赋值给变量s。然后，我们将变量s传递给函数calculate_length，该函数接受该字符串的所有权。该函数返回该字符串的长度和该字符串本身。我们使用元组来返回这两个值。当程序执行到println!宏时，它打印字符串s的值和变量len的值。当程序执行完毕时，变量s超出了其作用域，该值将被自动释放。 需要注意的是，在函数中接受值的所有权时，该值将被移动。如果我们想在函数中使用该值的引用而不是移动它，我们可以使用借用。例如：

1
fn main() {
2
    let s = String::from("hello");
3
    let len = calculate_length(&s);
4
    println!("The length of '{}' is {}.", s, len);
5
}
6

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

在这个例子中，我们创建了一个字符串hello并将其赋值给变量s。然后，我们将变量s的引用传递给函数calculate_length，该函数借用该字符串的所有权。该函数返回该字符串的长度。当程序执行到println!宏时，它打印字符串s的值和变量len的值。当程序执行完毕时，变量s超出了其作用域，但由于我们只是借用了它，所以该值并没有被释放。

所有权和结构体#

在Rust中，结构体可以拥有值的所有权。例如：

1
struct Person {
2
    name: String,
3
    age: u8,
4
}
5

6
fn main() {
7
    let p = Person {
8
        name: String::from("Alice"),
9
        age: 30,
10
    };
11
    println!("{} is {} years old.", p.name, p.age);
12
}

在这个例子中，我们定义了一个结构体Person，它有两个字段：name和age。name字段是一个字符串，age字段是一个无符号8位整数。然后，我们创建了一个Person实例并将其赋值给变量p。该实例拥有name字段的所有权和age字段的所有权。当程序执行到println!宏时，它打印变量p的name字段和age字段的值。当程序执行完毕时，变量p超出了其作用域，该值将被自动释放。 需要注意的是，在结构体中拥有值的所有权时，该值将被移动。如果我们想在结构体中使用该值的引用而不是移动它，我们可以使用借用。例如：

1
struct Person<'a> {
2
    name: &'a str,
3
    age: u8,
4
}
5

6
fn main() {
7
    let name = String::from("Alice");
8
    let p = Person {
9
        name: &name,
10
        age: 30,
11
    };
12
    println!("{} is {} years old.", p.name, p.age);
13
}

在这个例子中，我们定义了一个结构体Person，它有两个字段：name和age。name字段是一个字符串的引用，age字段是一个无符号8位整数。然后，我们创建了一个字符串Alice并将其赋值给变量name。然后，我们创建了一个Person实例并将其赋值给变量p。该实例借用了变量name的值。当程序执行到println!宏时，它打印变量p的name字段和age字段的值。当程序执行完毕时，变量name和变量p超出了其作用域，但由于我们只是借用了它们，所以这些值并没有被释放。

所有权和Vec#

在Rust中，Vec是一个动态数组，它可以拥有值的所有权。例如：

1
fn main() {
2
    let v = vec![1, 2, 3];
3
    for i in &v {
4
        println!("{}", i);
5
    }
6
}

在这个例子中，我们创建了一个Vec实例并将其赋值给变量v。该实例拥有三个整数的所有权。然后，我们使用for循环遍历v的引用并打印每个值。当程序执行完毕时，变量v超出了其作用域，该值将被自动释放。 需要注意的是，在Vec中拥有值的所有权时，该值将被移动。如果我们想在Vec中使用该值的引用而不是移动它，我们可以使用借用。例如：

1
fn main() {
2
    let v = vec![String::from("hello"), String::from("world")];
3
    for s in &v {
4
        println!("{}", s);
5
    }
6
}

在这个例子中，我们创建了一个Vec实例并将其赋值给变量v。该实例拥有两个字符串的所有权。然后，我们使用for循环遍历v的引用并打印每个字符串。当程序执行完毕时，变量v超出了其作用域，但由于我们只是借用了它们，所以这些值并没有被释放。

所有权和闭包#

在Rust中，闭包可以拥有值的所有权。例如：

1
fn main() {
2
    let v = vec![1, 2, 3];
3
    let sum = |v: Vec<i32>| -> i32 {
4
        let mut total = 0;
5
        for i in v {
6
            total += i;
7
        }
8
        total
9
    };
10
    println!("{}", sum(v));
11
}

在这个例子中，我们创建了一个Vec实例并将其赋值给变量v。然后，我们创建了一个闭包sum，它接受一个Vec并返回一个i32。该闭包拥有v的所有权。然后，我们调用闭包sum并将变量v作为参数传递给它。该闭包计算v中所有整数的总和并返回该总和。当程序执行到println!宏时，它打印变量sum(v)的值。当程序执行完毕时，变量v超出了其作用域，该值将被自动释放。 需要注意的是，在闭包中拥有值的所有权时，该值将被移动。如果我们想在闭包中使用该值的引用而不是移动它，我们可以使用借用。例如：

1
fn main() {
2
    let v = vec![1, 2, 3];
3
    let sum = |v: &Vec<i32>| -> i32 {
4
        let mut total = 0;
5
        for i in v {
6
            total += i;
7
        }
8
        total
9
    };
10
    println!("{}", sum(&v));
11
}

在这个例子中，我们创建了一个Vec实例并将其赋值给变量v。然后，我们创建了一个闭包sum，它接受一个&Vec并返回一个i32。该闭包借用了v的值。然后，我们调用闭包sum并将变量v的引用作为参数传递给它。该闭包计算v中所有整数的总和并返回该总和。当程序执行到println!宏时，它打印变量sum(&v)的值。当程序执行完毕时，变量v超出了其作用域，但由于我们只是借用了它们，所以这些值并没有被释放。

总结#

在Rust中，所有权系统是一种内存管理方式，它可以避免常见的内存问题，如空指针、内存泄漏和数据竞争。在本教程中，我们深入了解了Rust的所有权系统，并了解了如何使用它来管理内存。我们学习了值的所有权、所有权的转移、所有权的借用、可变借用、所有权和函数、所有权和结构体、所有权和Vec、所有权和闭包等概念。希望本教程能够帮助你更好地理解Rust的所有权系统。