需求很小:写一个函数,把 "WARN disk usage 91%" 这样的一行日志拆成级别和正文。第一版写出来是这样的:
fn parse_line(line: &str) -> (&str, &str) {
let (level, message) = line.split_once(' ').unwrap();
(level, message)
}
看起来很自然,编译也过了。接着有人想把它包进一个结构体,方便后续处理:
struct LogEntry {
level: &str,
message: &str,
}
编译立刻失败,报的是 missing lifetime specifier。改上加号也不行,编译器接着问你要标哪个生命周期。到这一步,大部分人才第一次真正碰到「借用活多久」这个问题——它不是语法糖,是类型系统在问你一个必须回答的问题:这个结构体里的引用,指向的数据由谁保证一直活着?
这篇用一个完整的解析器场景,把 move、借用、生命周期三件事串起来。目标不是让你背规则,而是看到报错时能立刻判断该改哪里。
场景走查:从一行日志到结构体
先明确需求:输入是一整块日志文本,按行切分,每行解析成级别和正文;解析结果要在内存里保留一段时间,供后续过滤和统计。这里有一个关键选择:解析结果是指向原始文本的切片,还是各自复制一份字符串。
先看借用版本,它最省内存:
struct ParsedLine<'a> {
level: &'a str,
message: &'a str,
}
fn parse_line(line: &str) -> Option<ParsedLine<'_>> {
let (level, message) = line.split_once(' ')?;
Some(ParsedLine { level, message })
}
fn main() {
let line = String::from("WARN disk usage 91%");
if let Some(p) = parse_line(&line) {
println!("[{}] {}", p.level, p.message);
}
}
cargo run 输出:
[WARN] disk usage 91%
这段代码里,ParsedLine<'a> 的意思是:这个结构体不拥有字符串,它内部的两个字段借用了别的数据,借多久由 'a 表示。parse_line 的返回值写成 ParsedLine<'_>,下划线让编译器根据输入自动推断——返回的引用来自 line 参数,所以 '_ 就是 line 的生命周期。
为什么结构体必须写生命周期,而函数可以不写?因为函数有「生命周期省略规则」:只有一个引用参数时,返回值的生命周期默认等于它。结构体没有这种默认规则,编译器无法猜,只能要求你写明。
生命周期标注在标什么
先纠正一个常见误解:生命周期标注不会让变量活得更久,也不会改变运行时的任何行为。它只是告诉编译器「这几个引用之间的关系」,让编译器能检查使用是否越界。
最典型的是「返回较长的那个字符串」:
fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
if a.len() >= b.len() { a } else { b }
}
不写 'a 时,编译器会报:
error[E0106]: missing lifetime specifier
|
1 | fn longest(a: &str, b: &str) -> &str {
| ---- ---- ^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but the signature
does not say whether it is borrowed from `a` or `b`
help: consider introducing a named lifetime parameter
|
1 | fn longest<'a>(a: &'a str, b: &'a str) -> &'a str
| ++++ ++ ++ ++
关键在 does not say whether it is borrowed from a or b 这句。编译器不是说代码有内存错误,而是说签名信息不足:调用方拿到返回值后,要按 a 的存活时间管还是按 b 的管?两者可能差很远。标上 'a 之后,约定变成「返回值活得不超过 a 和 b 中较短的那个」,调用方和函数体都按这个约定接受检查。
再看一个会直接出错的场景:让解析结果活得比原始字符串更久。
fn main() {
let p;
{
let line = String::from("WARN disk usage 91%");
p = parse_line(&line).unwrap();
}
println!("{}", p.level);
}
error[E0597]: `line` does not live long enough
|
14 | let line = String::from("WARN disk usage 91%");
| ---- binding `line` declared here
15 | p = parse_line(&line).unwrap();
| ^^^^^ borrowed value does not live long enough
16 | }
| - `line` dropped here while still borrowed
17 | println!("{}", p.level);
| ------- borrow later used here
翻译:p 里的字段指向 line 占用的内存,line 在代码块结束时就释放了,后面再用 p 就是读已释放的内存。这就是 C 里的悬垂指针,Rust 把它变成了编译错误。改法只有两种:让 line 活得更久(把它挪到外层),或者让 p 拥有自己的字符串(to_string())。
move、Copy 和 Clone 的区别
赋值、传参、从函数返回、放进集合,都可能触发所有权转移。哪些类型会被「移走」,取决于它有没有实现 Copy。
Copy
整数、浮点、布尔、字符、只含 Copy 字段的元组和数组、共享引用 &T。赋值时按位复制,原变量仍然可用。没有堆内存,不需要析构。
Move
String、Vec、Box、HashMap 等拥有堆内存的类型。赋值后原变量失效,编译器阻止你再使用。
Clone
显式复制一份完整数据,包括堆上的内容。原变量仍然可用,但你要为这次复制付出时间和内存。克隆是「我知道这里要花一次钱」的声明。
实际代码里,最常见的三种修法:
// 1. 后面还要用原值:传引用
fn print_all(items: &[String]) {
for item in items {
println!("{item}");
}
}
// 2. 确实需要两份独立数据:clone
let a = String::from("alpha");
let b = a.clone();
// 3. 只需要读一部分:借用切片
let s = String::from("WARN disk");
let level = &s[..4];
什么时候该 clone,判断标准不是「编译器让不让」,而是「这里复制一份是否合理」。日志行解析结果如果只在本次请求内使用,借用就够了;如果要把结果塞进队列、发给别的线程、或者返回给上层长期保存,那就老老实实 to_string(),因为原始文本随时可能被释放。
clone 消掉所有报错,是在把 Rust 当 GC 语言用。每一次 clone 都是真实的内存分配和拷贝,热点路径上会直接反映在延迟和内存占用上。先问「能不能借」,再问「要不要拥有」,最后才考虑 clone。借用规则与「最后一次使用」
借用只有两条规则,前面提过:同一时刻要么一个可变借用,要么任意多个不可变借用;借用不能超过所有者的生命周期。真正让人困惑的是「同一时刻」怎么算。Rust 用的是非词法生命周期(NLL):借用在最后一次使用处结束,而不是在代码块结束时结束。
所以下面这段是合法的:
fn main() {
let mut v = vec![1, 2, 3];
let first = &v[0];
println!("{first}");
v.push(4); // first 已经不再使用,借用提前结束
println!("{v:?}");
}
把 println!("{first}") 挪到 push 之后,才会报 E0502。编译器看的不是「变量在不在作用域内」,而是「这个引用还会不会被读」。这也是为什么很多报错会指着一行说「borrow later used here」——它找到了你最后一次使用的位置。
需要同时修改两个元素时,常见写法被借用检查器挡住:
let mut v = vec![1, 2, 3];
let a = &mut v[0];
let b = &mut v[1]; // error[E0499]: cannot borrow `v` as mutable more than once
println!("{a} {b}");
这不是编译器故意找麻烦。两个可变引用指向同一块 Vec 的缓冲区,编译器无法证明它们不重叠(下标是运行时值,可能是同一个)。标准库给了安全解法:
let (a, b) = v.split_at_mut(1);
println!("{} {}", a[0], b[0]);
split_at_mut 在类型层面把切片切成两段互不重叠的 &mut [i32],编译器就能证明安全。类似的还有 iter_mut、chunks_mut、windows,以及用下标索引分两次访问。
'static 与结构体里的引用
看到 'static 的人容易以为它是「全局变量」的同义词。它的准确含义是「这个引用在整个程序运行期间都有效」。字符串字面量就是 &'static str,因为它被编进二进制;Box::leak 返回的也是 &'static mut T,代价是这块内存再也不会被回收。
大多数业务代码里,'static 出现在错误类型和线程边界上:thread::spawn 要求闭包 'static,Box<dyn Error + 'static> 是常见约束。这不是让你把所有数据都设成静态,而是要求闭包不能借用栈上的临时变量——线程活多久你不知道,栈帧可能先没了。
结构体里放引用,会把这个生命周期传播给所有使用它的地方。一个 Parser<'a> 被放进另一个结构体,外层也要标 'a;再往上还会继续传。生命周期标注「传染」是真实存在的开发成本。两条降低成本的思路:
String、Vec、Arc,把生命周期问题换成所有权问题。如果想在结构体里同时持有数据和指向数据的引用(自引用结构),直接用安全 Rust 写不出来,因为结构体一旦移动,引用就失效。这类需求要用 Pin 加 unsafe,或者干脆改成「持有索引」而不是「持有引用」。入门阶段先避开这个坑,用索引或拥有数据都能解决绝大多数问题。
现象对照
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
borrow of moved value | 非 Copy 值被赋值或传参移走,原变量失效 | 看 value moved here 那一行,判断该 clone、改借用,还是调整调用顺序 |
cannot borrow as mutable because it is also borrowed as immutable | 引用还活着的时候调用了会改变容器的方法 | 找 borrow later used here,把修改挪到引用最后一次使用之后 |
cannot borrow as mutable more than once | 两个可变借用同时存在,编译器无法证明不重叠 | 用 split_at_mut、iter_mut,或改成先取出再写回 |
missing lifetime specifier | 结构体或函数签名里的引用关系没写清 | 看返回引用是否来自多个参数,加上同一生命周期或改用拥有类型 |
does not live long enough | 被借用的变量先于引用离开作用域 | 看 dropped here while still borrowed,把所有者挪到外层或改成 to_string() |
cannot move out of borrowed content | 通过 & 拿到了值还想把它移走 | 改成 &mut 用 std::mem::take/replace,或直接 clone |
| 函数返回引用后调用方编译不过 | 返回的引用指向函数内的局部变量 | 改成返回 String/Vec 等拥有所有权的类型 |
| 给结构体加生命周期后整个模块都要加 | 生命周期沿类型传播,属于设计成本 | 重新评估该类型是否应该拥有数据,而不是借用 |
边界与代价
所有权模型省掉了 GC 和手工释放,但它把一部分运行时问题挪到了设计阶段。最直接的代价是:数据结构必须先想清楚所有权,再写代码。链表、图、双向引用、父子节点这些结构,在 Rust 里需要额外的设计(索引、Rc<RefCell>、arena 分配),这不是语言缺陷,是「谁能释放谁」这个问题本来就需要答案。
第二个代价是 API 设计的约束。一个库如果要接受「任意可读的字符串」,参数应该写 &str 而不是 &String;如果要长期保存,就得要 String。这些选择会影响调用方,也影响后续能不能改成异步、能不能跨线程。设计签名时多花十分钟,比后期改一批调用点便宜。
第三个代价是错误信息的阅读成本。借用检查器的报错通常很长,涉及多个位置。新手容易只看第一行就猜,结果改错方向。正确做法是先读 help 和 note 段,它们往往直接给了修法;再看 borrow later used here,确认引用的实际存活范围。
第四个代价是 Rc<RefCell<T>> 这类组合的运行时开销和运行时 panic 风险。RefCell 把借用检查从编译期挪到运行期,违反规则会在运行时 panic,而且它不解决多线程问题。能用所有权和索引表达的结构,优先不用它。
最后,生命周期标注不是越多越好。函数签名里能省略就省略,结构体里能用拥有类型就用拥有类型。标注写得太满,会让签名难读,也会限制调用方的灵活性。让编译器推,推不出来再补。
小结
move 是所有权转移,Copy 是廉价复制,clone 是显式深拷贝;借用规则保证读写不冲突;生命周期标注只描述引用之间的关系,不改变存活时间。这三件事构成了 Rust 内存安全的地基。
遇到借用报错,按这个顺序问自己:这个值后面还要用吗?需要读还是需要改?数据要活多久?答案通常对应「借用 / clone / 改成拥有」三种改法之一。不要第一反应就 clone。
当天可以自己验证的练习:
- 把
ParsedLine的字段改成String,去掉生命周期参数,确认结构体能编译,再想想什么场景下必须这么做。 - 在
parse_line后面加一句line.push_str(" extra");,观察报错,理解不可变借用与可变借用的冲突。 - 用
split_at_mut同时修改Vec的两个元素,再对比直接两次&mut v[i]的报错。 - 写一个返回
&str的函数,让它返回局部String的切片,读完整报错,再用返回String修好。 - 把
longest的签名改成两个不同生命周期'a、'b,返回'a,体会「返回值只跟 a 绑定」的含义。
下一篇讲类型、模式匹配与 Option/Result。所有权解决的是「数据归谁」,接下来要解决「数据长什么样」:Rust 的类型系统怎么表达「可能没有」「可能失败」,match 为什么必须穷尽,以及那些看起来啰嗦的 Option 判断到底换来了什么。