所有权

所有权是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