所有权

是什么，为什么存在

所有权是 Rust 描述值由谁负责、何时转移责任以及何时结束值的一组语言规则。这里的值不只代表堆内存，也可能拥有文件、套接字、锁守卫或其他需要清理的资源。编译器在编译期检查规则，类型的析构逻辑则在运行时离开相应作用域时执行。

每个值都有一个当前所有者，同一份普通拥有型值不能被两个变量同时独立拥有。赋值、按值传参或按值返回可能把责任从一个位置转给另一个位置，这叫作 移动语义（move semantics） 。移动后拒绝旧绑定，能够让同一资源只由一条拥有路径负责释放。

所有者离开作用域时，Rust 会调用值的析构逻辑，然后释放它拥有的资源。这个模式是 资源获取即初始化（Resource Acquisition Is Initialization，RAII） ：资源生存期绑定到拥有它的值，而不是依靠垃圾回收器稍后寻找不可达对象。释放时机通常由控制流与作用域直接决定。

并非每次赋值都会让源绑定失效。实现 Copy 的类型在赋值和按值传参时会隐式复制，例如整数、布尔值以及只含 Copy 字段的许多结构体。拥有堆缓冲区的 String 不实现 Copy，所以赋值默认移动；需要另一份字符串数据时，可以显式调用 clone()。

借用（borrowing） 允许函数临时访问值而不取得所有权。&T 表示共享借用，&mut T 表示独占可变借用。所有权回答“谁最终负责结束这个值”，借用回答“谁可以在某段时间访问这个值”。

你会在函数签名、集合迭代、模式匹配、闭包捕获和线程边界中不断遇到所有权。它不是一条要求“永远不要复制”的性能规则，而是一种资源责任模型。先把责任表达准确，再用分析与测量决定是否需要减少复制或分配。

工作原理

理解所有权时，应区分绑定、值与资源。变量名绑定到一个值，值又可能拥有别处的资源；例如 String 值管理一段可增长的 UTF-8 缓冲区。移动 String 会转移管理缓冲区的责任，不会创建第二份字符串内容。

Rust 教材常把基本规则概括为下面三条：

1. 每个值都有一个所有者。
2. 同一时刻只能有一个所有者。
3. 所有者离开作用域时，值会被丢弃。

这三条描述默认的单一所有权。Rc<T> 与 Arc<T> 等类型通过自身 API 建模多个拥有句柄，但“最后一个强所有者负责结束值”的责任仍然明确。共享所有权的具体计数和线程规则属于智能指针主题。

移动是一种静态状态变化

对非 Copy 值执行 let next = current; 后，next 成为所有者。编译器把 current 视为已移动，而不是等到运行时检查它是否还能使用。只要所有控制流路径都能证明绑定重新获得了一个值，就可以再次给旧变量赋值并使用新值。

按值参数也会移动值，因为被调用函数的参数是新的拥有位置。按值返回则把返回值移动给调用方。编译器会消除许多仅为表达语义的搬运，因此语言层面的移动不等于“复制整个堆对象”。

移动可以只发生在结构体的一个字段上。此后未移动字段仍可分别使用，但整个结构体通常不能再作为完整值使用。实现 Drop 的类型受到更严格限制，因为析构函数必须看到完整、有效的 self。

Copy 与 Clone 是不同契约

Copy 是一个没有方法的标记 trait。类型实现它后，普通赋值保持源绑定可用；这种复制不能运行自定义代码。实现 Drop 的类型不能同时实现 Copy，因为隐式复制会让“哪一份负责析构”变得含糊。

Clone 提供显式的 clone() 方法，并允许类型定义如何创建逻辑副本。克隆 String 会复制字符数据；克隆 Rc<T> 只会增加共享所有者计数；克隆自定义类型的语义取决于它的实现。看到 .clone() 时，必须根据接收者类型判断成本和所有权含义。

Copy 也不是“存储在栈上”的同义词。共享引用和一些包含指针的值可以实现 Copy，而某些固定大小的栈上值因为拥有资源或实现 Drop，不能实现 Copy。判断依据是类型契约，不是你猜测的存储位置。

借用保留所有权边界

函数只需在调用期间读取值时，通常接收 &T。需要修改、但不需要保留值时，通常接收 &mut T。函数需要存储、转交或最终销毁值时，按值接收 T 才准确表达责任变化。

借用有自己的有效区间，引用不能比所有者活得更久，冲突的共享访问与可变访问也不能重叠。编译器通常在引用最后一次使用后结束借用，而不是机械地延伸到右花括号。更完整的冲突规则和生命周期标注分别由相关主题展开。

Drop 完成责任交接

离开作用域时，Rust 自动调用 Drop::drop，调用方不能直接调用这个方法。需要提前结束值时，标准库的 drop(value) 按值取得它，让值在函数返回前完成析构。对引用调用 drop(&value) 只会结束那个可复制的引用，不会析构被引用值。

局部变量通常按声明的逆序丢弃，结构体字段按声明顺序丢弃。提前 return 和发生栈展开的 panic 也会丢弃已经初始化且仍存活的局部值。std::process::exit、中止进程和引用计数强环等路径可能绕过预期析构，因此所有权保证内存安全，并不保证每个析构函数必然运行。

示例

下面四个程序分别展示按值转移、Copy 与 Clone、借用以及确定性析构。它们都使用 Rust 1.98.0 的本地 cargo run 实际执行，输出块保留真实结果。

把所有权移入函数再返回

approve 按值接收 Ticket，所以调用时所有权从 main 移入函数。返回值又把所有权交还调用方；用同名绑定接住结果，可以把一次状态转换写成连续流程。

第一个 ticket 在调用后已移动，第二个同名绑定拥有返回的值。这种遮蔽不会恢复旧值，只是让新所有者沿用领域中合适的名称。如果 approve 不需要保留或返回票据，改成接收 &mut Ticket 可以让调用方始终持有所有权。

比较隐式复制与显式克隆

整数实现 Copy，所以 retry_limit 在赋值后仍可使用。Shipment 包含 String，不能实现 Copy；派生的 Clone 则允许明确创建一份独立货运记录。

#[derive(Clone, Debug)]
struct Shipment {
    route: String,
    priority: u8,
}

fn main() {
    let retry_limit = 3;
    let copied_limit = retry_limit;

    let original = Shipment {
        route: String::from("Paris-Lyon"),
        priority: 1,
    };
    let mut rerouted = original.clone();
    rerouted.route = String::from("Paris-Dijon");
    rerouted.priority = 2;

    println!("limits: {retry_limit}, {copied_limit}");
    println!("original: {original:?}");
    println!("rerouted: {rerouted:?}");
}

limits: 3, 3
original: Shipment { route: "Paris-Lyon", priority: 1 }
rerouted: Shipment { route: "Paris-Dijon", priority: 2 }

修改克隆值不会修改原值，因为两个 String 各自拥有缓冲区。这个结论来自 Shipment 的派生 Clone 逐字段克隆；不能把它推广为所有 .clone() 都会深拷贝。对于共享指针，克隆通常创建另一个拥有句柄。

用借用避免转移

note_count 只读订单，因此接收 &Order；add_note 需要修改订单，因此接收 &mut Order。两个函数都不保留订单，所有权从始至终留在 main。

#[derive(Debug)]
struct Order {
    number: String,
    notes: Vec<String>,
}

fn note_count(order: &Order) -> usize {
    order.notes.len()
}

fn add_note(order: &mut Order, note: &str) {
    order.notes.push(note.to_owned());
}

fn main() {
    let mut order = Order {
        number: String::from("A-17"),
        notes: vec![String::from("paid")],
    };

    println!("{} has {} note", order.number, note_count(&order));
    add_note(&mut order, "packed");
    println!("{} has {} notes", order.number, note_count(&order));
}

A-17 has 1 note
A-17 has 2 notes

第一次共享借用在 println! 结束后不再使用，所以随后的可变借用合法。note 是借入的 &str，但订单需要在函数返回后保存内容，因此 to_owned() 在真正的持有边界创建 String。这次分配是接口语义的一部分，不是为了安抚编译器。

观察作用域与显式 drop

Traced 的析构函数打印名称，使丢弃顺序可见。内部的 _buffer 在代码块结束时自动丢弃；connection 则通过 drop 提前结束。

struct Traced(&'static str);

impl Drop for Traced {
    fn drop(&mut self) {
        println!("drop {}", self.0);
    }
}

fn main() {
    let connection = Traced("connection");
    {
        let _buffer = Traced("buffer");
        println!("inside scope");
    }

    println!("after inner scope");
    drop(connection);
    println!("after explicit drop");
}

inside scope
drop buffer
after inner scope
drop connection
after explicit drop

drop(connection) 消费该值，因此后面不能再使用 connection。真实类型的析构函数通常释放资源而不打印；输出只是把时间点显式化。需要释放锁守卫时也应丢弃守卫本身，不能丢弃指向守卫的引用。

陷阱

移动后继续使用旧绑定

修复： 检查被调用方是否需要保留或销毁值。只读改用 &T，原地修改改用 &mut T，确实转交责任就让调用方不再使用旧绑定，或由函数返回所有权。只有契约需要两个独立值时才克隆。

用 clone 消除每个所有权错误

修复： 为每次克隆写出“新副本由谁持有、为何必须独立”。先尝试缩短借用、移动值或修改参数类型；保留的克隆应通过类型语义和必要时的测量验证，而不是用笼统的“克隆很便宜”解释。

根据存储位置猜测 Copy

修复： 查看类型是否实现 Copy，以及所有字段是否允许该实现。自定义类型只有在隐式复制符合领域语义时才应派生 Copy；如果复制需要显式确认、分配或计数更新，就使用 Clone 或保留移动语义。

忽略部分移动

修复： 只需读取时在模式中使用 ref 或匹配引用。确实要取走字段时，可以重构为完整解构，或把字段建模为 Option<T> 并用 take() 留下有效状态；不要通过不安全代码绕过析构不变量。

把析构当成必达事件

修复： 让文件、锁与事务由尽可能小的词法作用域管理，并避免把关键持久化动作只放在 Drop 中。为引用图标出拥有边，给非拥有反向边使用 Weak；对正常关闭流程显式提交或刷新，再把析构作为异常路径的保障。

延伸阅读

• Rust 程序设计语言：所有权
• Rust 程序设计语言：引用与借用
• Rust Reference：析构函数
• Rust 标准库：Clone
• Rust 标准库：Copy