目录

8. 所有权

学习目标

1.1 什么是所有权

Rust 使用所有权系统来管理内存。每个值在任意时刻都有且只有一个变量作为它的所有者(owner)。当所有者离开作用域,值就会被自动释放。

所有权的三个规则

  1. Rust 中的每个值都有一个所有者。
  2. 同一时间只能有一个所有者。
  3. 当所有者离开作用域,值将被丢弃。

1.2 变量作用域

作用域是变量有效的范围,由花括号 {} 界定:

snippet.rust
fn main() {
    let s = "hello"; // s 从这里开始有效    println!("{}", s);
} // s 在这里离开作用域,内存被释放

对于字符串字面量 "hello",它是不可变的、编译时已知的,存储在栈上。但动态字符串 String 则不同。

1.3 `String` 类型的内存分配

snippet.rust
fn main() {
    let mut s = String::from("hello");
    s.push_str(", world!"); // 可以修改
    println!("{}", s);
}

String 的数据存储在堆上,包含三部分: - 指向堆内存的指针 - 长度(已用字节数) - 容量(已分配字节数)

![String 内存结构示意:栈上存 ptr/len/capacity,堆上存实际字符数据]

1.4 所有权转移:move

当一个 String 赋值给另一个变量时,所有权会发生转移(move),而不是浅拷贝:

snippet.rust
fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1 的所有权移动到 s2
 
    // println!("{}", s1); // 错误:s1 不再有效
    println!("{}", s2);
}

为什么?如果 s1 和 s2 同时指向同一块堆内存,当它们离开作用域时,这块内存会被释放两次(double free),导致内存不安全。Rust 通过禁止 s1 继续使用来避免这个问题。

注意:整数、浮点数、布尔值等基本类型不会发生 `move`,因为它们实现了 `Copy` trait。

## 1.5 Clone:深拷贝

如果你确实需要两个独立的 String 副本,可以使用 clone():

snippet.rust
fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone();
 
    println!("s1 = {}, s2 = {}", s1, s2); // 两者都有效
}

clone() 会复制堆上的数据,因此代价较高。只有在确实需要时才使用。

1.6 `Copy` trait:栈上数据的复制

对于完全存储在栈上的简单类型,Rust 提供了 Copy trait:

snippet.rust
fn main() {
    let x = 5;
    let y = x; // x 被复制到 y,x 仍然可用
 
    println!("x = {}, y = {}", x, y);
}

实现了 Copy trait 的类型在赋值时会被复制,而不是移动。常见的 Copy 类型包括:

1.7 所有权与函数

将值传给函数,相当于把值移动或复制给函数的参数:

snippet.rust
fn main() {
    let s = String::from("hello");
    takes_ownership(s); // s 的所有权移动到函数内部
    // println!("{}", s); // 错误:s 不再有效
 
    let x = 5;
    makes_copy(x); // x 被复制,之后仍可用
    println!("{}", x);
}
 
fn takes_ownership(some_string: String) {
    println!("{}", some_string);
} // some_string 离开作用域,内存被释放
 
fn makes_copy(some_integer: i32) {
    println!("{}", some_integer);
}

1.8 返回值与所有权

函数返回值也可以转移所有权:

snippet.rust
fn main() {
    let s1 = gives_ownership(); // gives_ownership 将返回值的所有权转移给 s1
    let s2 = String::from("hello");
    let s3 = takes_and_gives_back(s2); // s2 被移入函数,s3 接收返回值的所有权
}
 
fn gives_ownership() -> String {
    let some_string = String::from("yours");
    some_string // 返回值的所有权转移给调用者
}
 
fn takes_and_gives_back(a_string: String) -> String {
    a_string // 将传入的字符串所有权返回
}

1.9 小结

操作 效果 原变量是否可用
let s2 = s1;(String) move 否
let s2 = s1.clone(); 深拷贝 是
let y = x;(i32 等 Copy 类型) 复制 是
传参给函数 move / 复制 非 Copy 类型不可用
函数返回 所有权转移 接收方可用

1.10 思考题

  1. 下面代码为什么会报错?如何修改? rust fn main() { let s = String::from("hello"); let t = s; println!("{}", s); }
  2. 什么情况下应该使用 clone()?什么情况下应该避免?
  3. 元组 (i32, String) 被赋值给另一个变量后,原变量还能用吗?为什么?