Rust 所有权实战练习全解:从 move、clone 到部分移动(Partial Move)

原创2026-09-21 20:46:241,828 阅读
文章标签:文档教程教育

Rust 所有权实战练习全解:从 move、clone 到部分移动(Partial Move)

所有权(Ownership)是 Rust 区别于其他系统编程语言最核心的机制,也是新手最容易踩坑的关卡。本文以 rust-by-practice 仓库 所有权练习文档 为骨架,配合官方 练习答案,逐一拆解 9 道由易到难(🌟 到 🌟🌟🌟)的练习题,覆盖 move 语义、clone/copy 区分、函数参数的所有权进出、可变性随所有权转移、以及最易混淆的"部分移动(partial move)"。读完本文,你将能准确判断任意值在赋值、传参、解构场景下"谁拥有它、能否继续使用"这一 Rust 程序员的基本功。

一、练习环境与背景

本仓库是一本"用挑战性练习驱动学习"的 Rust 实战手册,每个章节由示例(examples)、练习(exercises)和实战(practices)三部分组成,练习支持在线编辑与运行。本主题属于"所有权和借用"章节(见 SUMMARY.md),前置导航页 intro.md 将学习资料指向 Rust Book 第 4.1–4.4 节。

在开始做题前,请先确认运行环境。仓库使用 mdBook 构建,编译目标为 Rust 2021 edition(见 zh-CN/book.toml),这意味着你本地的 Rust 工具链需为 1.56+ 版本才能与练习的语义一致。本地阅读文档的方式:

cd rust-by-practice
mdbook serve zh-CN/   # 中文版

练习中的代码块带有 editable 标记,可在浏览器中直接编辑运行;每道题都配有参考答案,存放于仓库 solutions 目录。

二、基础题:move 语义与 clone / copy 的抉择

练习 1:String 的移动(Move)——如何让两个变量都能用?

原题要求"使用尽可能多的方法让代码通过编译":

fn main() {
    let x = String::from("hello, world");
    let y = x;
    println!("{},{}",x,y);
}

直接编译会报错 value moved here,因为 String 是堆分配类型,let y = x 会把 x 的所有权转移给 y,此后 x 失效。参考答案给出了四种思路:

// 方案一:clone 深拷贝,x 和 y 各自拥有一份堆数据
fn main() {
    let x = String::from("hello, world");
    let y = x.clone();
    println!("{},{}",x,y);
}

// 方案二:字面量 &str 实现了 Copy,整体复制
fn main() {
    let x = "hello, world";
    let y = x;
    println!("{},{}",x,y);
}

// 方案三:让 y 成为指向 String 的引用(借用),不转移所有权
fn main() {
    let x = &String::from("hello, world");
    let y = x;
    println!("{},{}",x,y);
}

// 方案四:借用 x 的字符串切片
fn main() {
    let x = String::from("hello, world");
    let y = x.as_str();
    println!("{},{}",x,y);
}

四个方案分别对应四条 Rust 规则,值得逐条理解:

  • 方案一(clone):Clone trait 做深拷贝,代价是堆内存复制;语义上"我复制一份给你"。
  • 方案二(Copy 类型):字符串字面量类型 &str 本身实现了 Copy,赋值时按位复制、原变量仍可用,y 与 x 指向同一份字面量数据。
  • 方案三(引用):&String 是对堆上 String 的不可变引用,y = x 复制的是引用本身(引用也实现 Copy),所有权仍在原 String 上。
  • 方案四(切片):x.as_str() 借用堆数据,返回 &str,同样不转移所有权。

判断要点:只要类型实现了 Copy(基本数值、bool、char、&T、只含 Copy 成员的元组/数组等),赋值即复制;否则赋值即 move。String、Vec<T>、Box<T> 这类堆类型都没有实现 Copy,只能 clone() 或借用。

练习 2:函数传参是 move——如何"还回来"?

// 不要修改 main 中的代码
fn main() {
    let s1 = String::from("hello, world");
    let s2 = take_ownership(s1);

    println!("{}", s2);
}

// 只能修改下面的代码!
fn take_ownership(s: String) -> String {
    println!("{}", s);
    s
}

答案的核心是把 take_ownership 的返回类型从 () 改为 String,并把参数 s 原样返回:

fn take_ownership(s: String) -> String {
    println!("{}", s);
    s
}

这把"所有权借出-归还"模式讲透了:把值传入函数等于把所有权 move 进函数,函数若想继续让调用方使用,必须把所有权作为返回值"吐出来"。这也是 Rust 中"值传递 + 返回"模式的雏形,与后面章节 引用和借用 介绍的 &T 借用形成对照——借用可以避免这种来回搬运。

练习 3:into_bytes 会吞掉所有权

fn main() {
    let s = give_ownership();
    println!("{}", s);
}

// 只能修改下面的代码!
fn give_ownership() -> String {
    let s = String::from("hello, world");
    // convert String to Vec
    // 将 String 转换成 Vec 类型
    let _s = s.as_bytes();
    s
}

原题注释提示"将 String 转换成 Vec 类型",容易写出 s.as_bytes()——但答案明确要求改成 s.into_bytes():

fn give_ownership() -> String {
    let s = String::from("hello, world");
    s
}

其实答案版本最简洁:直接返回 s。这题的陷阱在于:

  • as_bytes() 只借用(返回 &[u8]),不转移所有权,所以原版代码 s 依然可用,本意是想让你思考"哪个方法会转移所有权";
  • into_bytes()(into_ 前缀家族:into_bytes、into_iter 等)会消费 self,转移所有权,调用后 s 不能再使用;
  • 最佳答案就是不做任何转换,直接返回 s,所有权从函数内移交到 main。

这一题教会你辨别 &self 方法(借用)与 self 方法(消费/转移)两类 API 的签名语义。

练习 4:修复错误,不删任何代码——引用传参

fn main() {
    let s = String::from("hello, world");

    print_str(s);

    println!("{}", s);
}

fn print_str(s: String)  {
    println!("{}",s)
}

print_str(s) 把所有权 move 进了函数,后面 println!("{}", s) 必然报错。参考答案提供两种改法:

// 改法一:先 clone 一份传进去,原值保留
fn main() {
    let s = String::from("hello, world");
    print_str(s.clone());
    println!("{}", s);
}
fn print_str(s: String)  {
    println!("{}",s)
}

// 改法二:改为传引用,不转移所有权(更优)
fn main() {
    let s = String::from("hello, world");
    print_str(&s);
    println!("{}", s);
}
fn print_str(s: &String)  {
    println!("{}",s)
}

当函数只需要"读"数据而不需要拥有它时,传 &String(或更常见的 &str)是零拷贝的推荐做法,这正是本仓库后续 借用练习 要展开的规则。

三、Copy 元组的细节:元组是否可 Copy 取决于成员

练习 5:不要用 clone,改用 copy

// 不要使用 clone,使用 copy 的方式替代
fn main() {
    let x = (1, 2, (), "hello".to_string());
    let y = x.clone();
    println!("{:?}, {:?}", x, y);
}

原题 x 是四元组 (i32, i32, (), String),其中 String 不可 Copy,所以整个元组只能 move,x.clone() 之后 x 仍可用是依赖深拷贝实现的。答案改为:

fn main() {
    let x = (1, 2, (), "hello");
    let y = x;
    println!("{:?}, {:?}", x, y);
}

把最后一个成员从 "hello".to_string()(String)改为字面量 "hello"(&str,实现了 Copy),此时整个元组的所有成员都是 Copy 类型,元组自身自动获得 Copy 派生,let y = x 变成按位复制,两个变量都可继续使用。

关键规律:元组/结构体是否实现 Copy,取决于其所有成员是否都实现 Copy;只要有一个成员是 String、Vec 等堆类型,整体就只能 move。

四、可变性:所有权转移时可以"由不可变变可变"

当所有权转移时,可变性也可以随之改变。

这是原文档在"可变性"小节给出的核心提示:绑定的 mut 只关乎"这个名字",不关乎底层数据是否被共享。

练习 6:让接收者可变

fn main() {
    let s = String::from("hello, ");

    // 只修改下面这行代码 !
    let s1 = s;

    s1.push_str("world")
}

push_str 需要 &mut self,因此接收者必须可变:

let mut s1 = s;

注意:s 的所有权已经转移给 s1,此处只给新绑定加 mut 即可,s 本身已失效无需声明可变。可变性跟随"当前持有者"走,而不是跟随原始声明。

练习 7:Box 解引用赋值

fn main() {
    let x = Box::new(5);

    let mut y = Box::new(3);       // 完成该行代码,不要修改其它行!

    *y = 4;

    assert_eq!(*x, 5);
}

*y = 4 通过解引用给 Box 指向的堆值赋值,所以 y 必须绑定为 mut:

let mut y = Box::new(3);

同时 x 依然可以通过 *x 读取(Box<T> 实现了 Deref),并满足 assert_eq!(*x, 5)。这题同时复习了 智能指针章节 的 Box 与解引用语法。

五、部分移动(Partial Move):解构时的所有权拆分

当解构一个变量时,可以同时使用 move 和引用模式绑定的方式。当这么做时,部分 move 就会发生:变量中一部分的所有权被转移给其它变量,而另一部分我们获取了它的引用。在这种情况下,原变量将无法再被使用,但是它没有转移所有权的那一部分依然可以使用,也就是之前被引用的那部分。

这是全篇最有深度、也最容易在面试与实战中翻车的知识点。

标准示例:结构体解构

fn main() {
    #[derive(Debug)]
    struct Person {
        name: String,
        age: Box<u8>,
    }

    let person = Person {
        name: String::from("Alice"),
        age: Box::new(20),
    };

    // name 的所有权被转移给新变量 `name`
    // 而 `age` 变量是对 person.age 的引用,ref 等价于 let age = &person.age
    let Person { name, ref age } = person;

    println!("The person's age is {}", age);
    println!("The person's name is {}", name);

    // Error! person 的一部分已转移所有权,整体不能再使用
    //println!("The person struct is {:?}", person);

    // 虽然 person 整体失效,但 person.age 依然可以使用(它只是被借用)
    println!("The person's age from person struct is {}", person.age);
}

逐句解读这段示例:

  1. let Person { name, ref age } = person; 中,name 字段(String)被 move 出新变量;age 字段通过 ref 模式被 借用,等价于 let age = &person.age;
  2. person 因为有一部分被 move 走,整体不可再使用——直接 println!("{:?}", person) 会报 borrow of partially moved value;
  3. 但被引用的字段 person.age 依然可以访问,因为它没有发生所有权转移,只是被借用;
  4. name 是独立的新 String,age 是指向原 Box 的引用。

ref 关键字与 & 类似(模式中的 ref 等价于创建引用),在本仓库 借用练习 中有配套习题(let ref r2 = c;)。

练习 8:元组的部分移动

fn main() {
   let t = (String::from("hello"), String::from("world"));

   let _s = t.0;

   // 仅修改下面这行代码,且不要使用 `_s`
   println!("{:?}", t);
}

t.0 被 move 到 _s 后,t 整体不能再用,因此 println!("{:?}", t) 报错。但 t.1 没有被 move,仍可单独使用:

println!("{:?}", t.1);

答案正是把打印对象从整个元组缩小为 t.1,印证了"部分 move 后,未转移的那部分仍可用"的规则。

练习 9:解构并 clone 整个元组

fn main() {
   let t = (String::from("hello"), String::from("world"));

   // 填空,不要修改其它代码
   let (__, __) = __;

   println!("{:?}, {:?}, {:?}", s1, s2, t); // -> "hello", "world", ("hello", "world")
}

输出要求 s1、s2、t 三者同时可用,而解构 let (s1, s2) = t 会整体 move 掉 t。所以必须对 t 做一次 clone() 再解构:

let (s1, s2) = t.clone();

此时 s1、s2 是克隆出来的两个独立 String,t 完好无损。对照练习 8 可以总结出"部分 move 与整体 clone 解构"的完整图景:想要部分保留就用字段级访问/ref 模式,想要整体保留就 clone。

六、与借用章节的衔接

所有权练习只是该章节的第一站,下一站是 引用和借用,其练习围绕 &T/&mut T、ref 关键字、借用规则(同一时刻多个不可变借用或一个可变借用)以及 NLL(Non-Lexical Lifetimes)展开,参考答案位于 solutions/ownership/borrowing.md。两节共同构成 Rust 内存安全模型的地基:所有权决定"数据归谁管",借用决定"谁能暂时看一眼或改一下"。

七、核心知识点速查

场景 行为 依据
let y = x;(x 为 String/Vec/Box) move,x 失效 练习 1、2
let y = x;(x 为 &str/i32/Copy 元组) 复制,x 仍可用 练习 1(方案二)、5
传值给函数 move 进函数,可返回值归还所有权 练习 2、3、4
只想读数据 传 &T 借用,零拷贝 练习 4
需要修改 接收者声明 mut 练习 6、7
解构时混合 move 与 ref 部分移动,整体失效、未移动字段可用 示例与练习 8
解构且整体仍需使用 先 clone() 再解构 练习 9
into_* 方法 消费 self,转移所有权 练习 3

所有权是 Rust 唯一需要"反直觉"思考的内存管理模型:没有垃圾回收,全靠编译期规则。把本文 9 道题在本地跑通、并亲手触发并阅读编译器的 value moved here、borrow of partially moved value 等错误信息,比背诵任何规则都有效。接下来建议进入 借用练习 继续巩固。

登录后查看全文
rust-by-practice