Rust 所有权实战练习全解:从 move、clone 到部分移动(Partial Move)
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):
Clonetrait 做深拷贝,代价是堆内存复制;语义上"我复制一份给你"。 - 方案二(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);
}
逐句解读这段示例:
let Person { name, ref age } = person;中,name字段(String)被 move 出新变量;age字段通过ref模式被 借用,等价于let age = &person.age;person因为有一部分被 move 走,整体不可再使用——直接println!("{:?}", person)会报borrow of partially moved value;- 但被引用的字段
person.age依然可以访问,因为它没有发生所有权转移,只是被借用; 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 等错误信息,比背诵任何规则都有效。接下来建议进入 借用练习 继续巩固。