8. 所有权

  • 理解 Rust 所有权的三个核心规则。
  • 掌握变量作用域与内存释放的关系。
  • 区分 move、clone 和 copy三种行为。
  • 理解函数参数传递与返回值如何影响所有权。

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

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

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

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

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

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

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

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

当一个 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() 会复制堆上的数据,因此代价较高。只有在确实需要时才使用。

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

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

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

  • 整型:i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize
  • 浮点型:f32, f64
  • 布尔型:bool
  • 字符型:char
  • 元组:当且仅当所有成员都实现 Copy 时,例如 (i32, bool) 是 Copy,但 (i32, String) 不是

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

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);
}

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

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 // 将传入的字符串所有权返回
}
操作 效果 原变量是否可用
let s2 = s1;(String) move 否
let s2 = s1.clone(); 深拷贝 是
let y = x;(i32 等 Copy 类型) 复制 是
传参给函数 move / 复制 非 Copy 类型不可用
函数返回 所有权转移 接收方可用
  1. 下面代码为什么会报错?如何修改? rust fn main() { let s = String::from("hello"); let t = s; println!("{}", s); }
  2. 什么情况下应该使用 clone()?什么情况下应该避免?
  3. 元组 (i32, String) 被赋值给另一个变量后,原变量还能用吗?为什么?

该主题尚不存在

您访问的页面并不存在。如果允许,您可以使用创建该页面按钮来创建它。

  • rust/所有权.txt
  • 最后更改: 2026/08/12 23:30
  • 由 张叶安