移动、部分移动与丢弃

是什么，为什么存在

Rust 把每个值交给一个拥有位置，可以是局部绑定、结构体字段、集合槽位，或其他能保存值的位置。所有者负责让值保持有效，并在正常离开作用域时执行析构。编译器会追踪这份责任，无需垃圾回收器，也无需运行时的所有者标记。

可以用三条规则建立工作模型：每个值都有所有者；普通值在同一时刻只有一个位置拥有；所有者离开作用域时，值被丢弃。Rc<T> 等共享所有权类型没有破坏这个模型，它们只是把被拥有的值变成计数句柄，再由句柄 API 决定内部值何时结束。

对于没有实现 Copy 的类型，赋值或按值函数调用通常会转移所有权。这就是 移动语义（move semantics） 。在编译器看来，源位置随后处于未初始化状态；要再次使用它，必须先在所有控制流路径上赋予新值。

借用（borrowing） 提供临时访问，而不更换所有者。共享引用 &T 允许读取，&mut T 则在其有效区域内允许独占修改。别名与生命周期规则由其他主题展开；在这里，引用的作用是让 API 避免转移所有权。

给 String 赋值、把领域对象传给辅助函数、迭代集合、解构值或释放守卫时，都会遇到这些规则。阅读 Rust 代码时，与其盯着字节位于哪里，不如先问下一步哪个位置有权使用这个值。

工作原理

所有权分析以位置和程序点为单位。在 let next = current; 中，两个名称都是位置。若值不是 Copy，next 变成已初始化，current 变成已移动；编译器不会为之后的访问插入运行时检查。

移动描述的是权限与责任，不要求机器层面真的复制数据。移动 String 会转移由指针、长度和容量组成的值，不会克隆 UTF-8 缓冲区。优化时，编译器甚至可能消除这次小型物理传递，但旧位置不能再读取的规则不变。

以下几种形式都会发生相同的转移：

1. 赋值把右侧的非 Copy 值移动到目标位置。
2. 按值实参把值移动到形参中。
3. 按值返回把结果移动到调用方的目标位置。
4. 向集合插入元素会把元素移动到集合中。
5. 消费型模式会移动它按值绑定的字段。

源位置可以在之后重新初始化。执行 let mut name = String::from("old"); let saved = name; 后，为 name 赋一个新的 String，这个位置便可再次使用。新赋值不会找回已移动的值，原值仍由 saved 拥有。

Copy 与 Clone 回答不同问题

Copy 是一个标记 trait，表示 Rust 可以隐式复制该值。整数、布尔值、共享引用，以及字段都满足条件的结构体是常见例子。带析构函数的类型不能实现 Copy，因为静默复制会让唯一清理责任变得含糊。

Clone 是显式操作，其含义由类型定义。克隆 String 会分配独立缓冲区；克隆 Rc<T> 则为同一分配创建另一个拥有句柄。看到 .clone() 只能说明代码请求了复制，无法单凭它判断成本，也无法判断结果是否共享状态。

不要根据值位于栈还是堆来猜测 Copy。共享引用即使指向堆分配也可以是 Copy；固定大小的值若拥有资源或定义了 Drop，也可以不是 Copy。trait 实现才是契约。

借用让责任留在调用方

类型为 T 的形参取得所有权，可以保存、转移或销毁该值。&T 形参可以临时读取，&mut T 可以临时修改，而调用方始终是所有者。选择范围最窄且准确的形式，调用点才会如实表达后续行为。

字符串 API 能清楚表现这个区别。只读取文本的辅助函数通常接收 &str，而不是 String 或 &String。组件若要在调用结束后继续保存文本，就需要拥有的 String，或者用生命周期关系证明借用仍然有效。

不兼容的移动或修改开始前，借用必须结束。不过，现代 Rust 会根据实际使用位置推导有效区域，而不只看右花括号。如果共享引用已经完成最后一次使用，同一代码块中之后的可变借用可以合法。这也是诊断会同时指出先前借用，以及让借用保持有效的后续使用的原因。

Drop 结束所有权路径

已初始化的所有者离开丢弃作用域时，Rust 会运行其析构函数，再销毁它拥有的值。把值的作用域与资源清理相连，就是 资源获取即初始化（Resource Acquisition Is Initialization，RAII） 。堆缓冲区、文件、套接字、锁守卫和普通字段都适用。

std::mem::drop 函数并不是特殊语法。它按值接收参数且不返回内容，所以所有权在调用内部结束。调用 drop(&guard) 只会丢弃复制出来的引用，守卫本身仍然存活，这是常见的锁生命周期错误。

示例

下面四个示例依次演示完整移动、复制、临时借用与字段提取。每个程序都用 Rust 1.98.0 在本地编译并运行，紧随其后的文本块是程序的标准输出。

移入函数再返回

dispatch 取得一个 Parcel，修改后再返回。调用点通过遮蔽继续使用同一个领域名称，但第二个绑定拥有的是返回值，并没有让第一个绑定复活。

当操作代表状态转移，或必须临时保存这个值时，取得再返回所有权很合适。如果目标只是在调用期间原地修改，使用 &mut Parcel 就不必交出再收回责任。

对比隐式 Copy 与显式 Clone

Window 的两个字段都满足条件，因此它可以实现 Copy。Route 含有 String，所以必须显式调用派生的 Clone；克隆出的路线拥有自己的字符串缓冲区。

#[derive(Copy, Clone)]
struct Window {
    start: u8,
    end: u8,
}

#[derive(Clone)]
struct Route {
    name: String,
    window: Window,
}

fn main() {
    let morning = Window { start: 8, end: 10 };
    let copied = morning;

    let original = Route {
        name: String::from("north"),
        window: morning,
    };
    let mut rerouted = original.clone();
    rerouted.name.push_str("-express");

    println!(
        "windows: {}-{} {}-{}",
        morning.start, morning.end, copied.start, copied.end
    );
    println!(
        "original: {} {}-{}",
        original.name, original.window.start, original.window.end
    );
    println!(
        "rerouted: {} {}-{}",
        rerouted.name, rerouted.window.start, rerouted.window.end
    );
}

windows: 8-10 8-10
original: north 8-10
rerouted: north-express 8-10

赋值复制了 Window，所以 morning 与 copied 都仍然有效。修改 rerouted.name 不会改变 original.name，因为派生的 Route::clone 会克隆每个字段，包括字符串拥有的数据。

通过借用读取和修改

label 只需要共享访问，reserve 需要独占可变访问。两个函数都不保存库存，因此两次调用前后，所有权始终留在 main 中。

#[derive(Debug)]
struct Inventory {
    warehouse: String,
    units: u32,
}

fn label(inventory: &Inventory) -> String {
    format!("{}:{}", inventory.warehouse, inventory.units)
}

fn reserve(inventory: &mut Inventory, units: u32) -> bool {
    if units > inventory.units {
        return false;
    }
    inventory.units -= units;
    true
}

fn main() {
    let mut inventory = Inventory {
        warehouse: String::from("CDG"),
        units: 5,
    };

    println!("before: {}", label(&inventory));
    println!("reserved: {}", reserve(&mut inventory, 2));
    println!("after: {}", label(&inventory));
}

before: CDG:5
reserved: true
after: CDG:3

第一个 println! 使用的共享借用在最后一次使用后结束，因此下一行可以开始可变借用。label 返回拥有型 String 是另一个设计决定：format! 创建了新文本，并没有暴露库存内部的视图。

移动一个字段并安全取出另一个

移动 first.address 是一次 部分移动（partial move） 。之后不能再使用完整的 first，但未受影响的 Copy 字段仍然可用。Option::take 采用另一种提取方式，会在原字段中留下 None。

#[derive(Debug)]
struct Delivery {
    address: String,
    attempts: u8,
    note: Option<String>,
}

fn main() {
    let first = Delivery {
        address: String::from("12 Rue Ada"),
        attempts: 1,
        note: None,
    };

    let address = first.address;
    println!("send {address} after {} attempt", first.attempts);

    let mut second = Delivery {
        address: String::from("8 Rust Lane"),
        attempts: 2,
        note: Some(String::from("side door")),
    };

    let note = second.note.take();
    println!("note: {note:?}");
    println!("remaining: {second:?}");
}

send 12 Rue Ada after 1 attempt
note: Some("side door")
remaining: Delivery { address: "8 Rust Lane", attempts: 2, note: None }

第一次提取没有为 address 留下替代值，所以之后只能分别访问剩余字段。第二个配送记录仍是完整的有效值，因为 take() 留下了合法的 Option::None；外围类型实现 Drop 时，这种模式尤其有用。

陷阱

把每次赋值都当作移动

修复方法： 检查具体类型是否实现 Copy。实现后，赋值会隐式复制；否则，除非表达式明确借用或克隆，都应按移动追踪。

在报错行添加 clone

修复方法： 检查第一次移动以及被调用方的契约。临时读取就借用，调用方不再使用就移动，责任需要交回就返回所有权；只有设计确实需要两个值或句柄时，才保留 clone()。

只读辅助函数却取得所有权

修复方法： 普通文本读取接收 &str，其他只读值接收 &T。只有函数要保存、转移、转换或有意销毁输入时，才接收 T。

部分移动后使用完整值

修复方法： 只需观察时匹配引用。必须提取时，可以消费并解构整个值，或者把字段放进 Option<T>，再用 take() 保持容器完整。

丢弃引用而不是守卫

修复方法： 把拥有型守卫传给 drop(guard)，或者把它放进更窄的代码块。启用编译警告，Rust 会提示对引用调用 drop 不会影响它指向的值。

延伸阅读

• Rust 程序设计语言：所有权是什么？
• Rust 程序设计语言：引用与借用
• Rust 参考：析构函数
• Rust 标准库：Copy
• Rust 标准库：Clone