所有权与借用：Rust 内存安全的核心

1
2

let x = 5;       // x 是整数 5 的所有者
let s = String::from("hello");  // s 是 String 的所有者

1
2
3
4
5

let s1 = String::from("hello");
let s2 = s1;  // 所有权从 s1 转移到 s1

// println!("{}", s1);  // 编译错误！s1 已失效
println!("{}", s2);  // ✅ s2 有效

1
2
3
4
5
6
7
8

error[E0382]: use of moved value: `s1`
 --> src/main.rs:4:20
  |
2 |     let s2 = s1;
  |         -- value moved here
3 |
4 |     println!("{}", s1);
  |                    ^^ value used here after move

1
2
3

{
    let s = String::from("hello");
}  // s 离开作用域，drop 被调用，内存自动释放

1
2
3
4

let x = 5;
let y = x;  // x 被复制到 y
println!("{}", x);  // ✅ x 仍然有效
println!("{}", y);  // ✅ y 也有效

1
2
3

let s1 = String::from("hello");
let s2 = s1;  // s1 的所有权移动到 s2
// println!("{}", s1);  // ❌ 编译错误

1
2
3
4

let s1 = String::from("hello");
let s2 = s1.clone();  // 深拷贝，两者都有效
println!("{}", s1);  // ✅
println!("{}", s2);  // ✅

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

fn takes_ownership(s: String) {
    println!("{}", s);
}  // s 离开作用域，drop 被调用

fn makes_copy(i: i32) {
    println!("{}", i);
}  // i 是 Copy 类型，离开作用域不会特别处理

fn main() {
    let s = String::from("hello");
    takes_ownership(s);
    // println!("{}", s);  // ❌ 编译错误：s 的所有权已被移动

    let x = 5;
    makes_copy(x);
    println!("{}", x);  // ✅ x 仍然有效
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

fn calculate_length(s: &String) -> usize {
    s.len()
}  // s 离开作用域，因为它是引用，不会 drop

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);

    println!(" '{}' 的长度是 {}", s1, len);
}

1
2
3
4
5
6
7
8
9

fn append_world(s: &mut String) {
    s.push_str(", world!");
}

fn main() {
    let mut s = String::from("hello");
    append_world(&mut s);
    println!("{}", s);  // 输出 "hello, world!"
}

1
2
3
4
5
6
7
8

let mut s = String::from("hello");

let r1 = &s;      // 不可变引用
let r2 = &s;      // ✅ 可以有多个不可变引用
println!("{} {}", r1, r2);

let r3 = &mut s;  // ❌ 编译错误：不能在已有不可变引用时创建可变引用
println!("{}", r3);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
 --> src/main.rs:6:14
  |
2 |     let r1 = &s;
  |              -- immutable borrow occurs here
...
4 |     let r2 = &s;
  |              -- immutable borrow occurs here
...
6 |     let r3 = &mut s;
  |              ^^^^^^ mutable borrow occurs here

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

let mut s = String::from("hello");

{
    let r1 = &s;
    let r2 = &s;
    println!("{} {}", r1, r2);
}  // r1 和 r2 离开作用域，不再使用

let r3 = &mut s;  // ✅ 现在可以创建可变引用
println!("{}", r3);

1
2
3
4
5
6
7
8
9

fn dangle() -> &String {
    let s = String::from("hello");

    &s  // ❌ 编译错误：返回指向 `s` 的引用，但 `s` 将被 drop
}

fn main() {
    let reference_to_nothing = dangle();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

error[E0106]: missing lifetime specifier
 --> src/main.rs:1:16
  |
1 | fn dangle() -> &String {
  |                ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `Owned` type instead
  |
1 | fn dangle() -> String {
  |                ~~~~~~~

1
2
3
4

fn no_dangle() -> String {
    let s = String::from("hello");
    s  // ✅ 所有权转移给调用者
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

use std::thread;

fn main() {
    let mut data = vec![1, 2, 3, 4];

    let handle = thread::spawn(|| {
        let r1 = &mut data[0];  // ❌ 编译错误：data 可能被其他线程访问
        *r1 += 1;
    });

    println!("{:?}", data);  // 同时访问 data
    handle.join().unwrap();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let data = Arc::new(Mutex::new(vec![1, 2, 3, 4]));

    let handle = thread::spawn({
        let data = Arc::clone(&data);
        move || {
            let mut vec = data.lock().unwrap();
            vec[0] += 1;
        }
    });

    {
        let vec = data.lock().unwrap();
        println!("{:?}", *vec);
    }
    handle.join().unwrap();
}

1
2
3
4

{
    let s = String::from("hello");
    // 使用 s
}  // 编译器自动插入 drop(&mut s)

1
2
3
4
5
6
7
8

fn longest(x: &str, y: &str) -> &str {
    // 这个函数无法编译！编译器不知道返回值借用了 x 还是 y
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

1
2
3
4
5
6
7

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}