所有权与移动

从一个 Go 程序的困惑出发

在 Go 里这段代码再普通不过:

s1 := "hello"
s2 := s1
fmt.Println(s1, s2) // hello hello,毫无问题

"翻译"成 Rust,却会被编译器拦下:

let s1 = String::from("hello");
let s2 = s1;
println!("{s1}"); // 编译错误:borrow of moved value: `s1`

同样是赋值,为什么 Rust 报错?答案就是所有权.理解了这个差异,就推开了 Rust 的大门.

所有权三条规则

整个系统建立在三条规则上,先记住,后面所有现象都由此推导:

1. Rust 中每个值都有一个所有者(owner).
2. 同一时刻,值有且只有一个所有者.
3. 当所有者离开作用域(scope),值被自动释放(drop).

第三条最关键:

{
    let s = String::from("hello"); // s 进入作用域,成为字符串的所有者
    // 这里可以使用 s
} // s 离开作用域,Rust 自动调用 drop,释放堆内存

没有 GC,也没有手动 free.释放点由作用域在编译期确定,运行时零额外开销--这是 Rust "零成本抽象"的第一个体现.

栈,堆与移动的本质

要理解为什么 String 赋值会"移动",得看清它的内存布局.String 分两部分:

栈(Stack)              堆(Heap)
      ┌─────────────┐        ┌───────────────┐
  s1  │ ptr   ──────┼───────▶│ h e l l o     │
      │ len   = 5   │        └───────────────┘
      │ cap   = 5   │
      └─────────────┘

栈上是一个"胖指针"(指向堆的指针 + 长度 + 容量),真正的字符内容在堆上.let s2 = s1 时,Rust 只复制栈上那三个字段,不复制堆数据(否则大字符串赋值会很昂贵).

于是 s1 和 s2 的指针指向同一块堆内存.若两者各自在离开作用域时 drop 一次,同一块内存就被释放两次(double free)--经典内存漏洞.Rust 的解法干脆:让 s1 失效,只有 s2 拥有这块数据.这个过程叫移动(Move),不是浅拷贝.

Copy:为什么整数不会被移动

立刻试探:整数赋值是不是也会失效?

let x = 5;
let y = x;
println!("{x} {y}"); // 5 5,完全正常

整数没被移动.因为 i32 这类类型完全在栈上,大小固定,复制廉价,没有堆数据要管理.Rust 为它们实现了 Copy trait:赋值时按位复制一份,原值依然有效.

常见的 Copy 类型:

• 所有整数,浮点,布尔,字符(char)
• 仅由 Copy 类型组成的元组,如 (i32, bool)
• 不可变引用 &T(下一篇详述)

而 String,Vec<T> 这类管理堆内存的类型,刻意没有实现 Copy,因此走移动.

Clone:需要副本时显式深拷贝

如果确实想要两份独立的堆数据,用 .clone() 显式深拷贝.Rust 强制深拷贝必须显式,正是为了让"这里有一次昂贵的内存复制"在代码里清晰可见:

let s1 = String::from("hello");
let s2 = s1.clone(); // 深拷贝:堆数据也复制一份
println!("{s1} {s2}"); // 两者都有效,各自拥有独立数据

函数调用中的移动

移动不只发生在赋值,把值传给函数同样移交所有权:

fn main() {
    let s = String::from("hello");
    takes_ownership(s); // s 的所有权移入函数
    // 这之后再用 s 会编译错误:s 已被移走
}

fn takes_ownership(text: String) {
    println!("{text}");
} // text 离开作用域,drop 被调用,内存释放

函数也能通过返回值把所有权还回来:

fn main() {
    let s1 = String::from("hello");
    let s2 = takes_and_gives_back(s1); // s1 移入,返回值移给 s2
    println!("{s2}");
}

fn takes_and_gives_back(text: String) -> String {
    text // 把所有权返回给调用方
}

这套"传进去,再传回来"很快会让人厌烦--只想读一下数据,却要交还所有权.这正是借用登场的理由,也是下一篇的主题.

与 Go 的整体对照