Rust 基础教程：所有权、借用、生命周期与系统编程
全面介绍 Rust 编程语言核心概念 — 所有权、借用、生命周期、特征、错误处理、并发等。学习 Rust 为何是系统编程的未来。
Rust 通过编译时所有权系统实现内存安全，无需垃圾回收器，同时保持 C/C++ 级别的性能。核心概念包括：所有权（每个值只有一个所有者）、借用（通过引用临时访问数据）、生命周期（确保引用始终有效）。掌握这三个概念，你就能写出安全、高效的系统级代码。
- 所有权规则：每个值只有一个所有者；所有者离开作用域时值被自动释放
- 借用规则：可以有多个不可变引用，或者恰好一个可变引用，但不能同时存在
- 生命周期注解确保引用不会比它引用的数据存活更长时间
- Result<T, E> 和 Option<T> 替代异常和 null，使错误处理显式化
- 特征（Trait）提供多态性，无需继承；泛型提供零成本抽象
- Arc<Mutex<T>> 用于多线程共享状态；通道用于消息传递
- Cargo 统一管理构建、测试、依赖和发布
Rust 是一门系统编程语言，运行速度极快，能防止段错误，并保证线程安全。自 2015 年发布 1.0 版本以来，Rust 在 Stack Overflow 开发者调查中连续八年被评为最受喜爱的编程语言。本指南将带你深入了解使 Rust 独特且强大的核心概念。
为什么选择 Rust？无 GC 的内存安全、性能与并发
大多数编程语言在两条路径中选择其一：手动内存管理（C、C++）追求性能，或垃圾回收（Go、Java、Python）追求安全。Rust 走第三条路——通过所有权系统在编译时强制保证内存安全，零运行时开销。
Rust 的三大支柱
Rust 建立在三个核心承诺之上：
- 内存安全 — 无空指针解引用、无释放后使用、无缓冲区溢出
- 线程安全 — 数据竞争是编译错误，不是运行时崩溃
- 零成本抽象 — 高级代码编译成与手写 C 一样高效的机器码
所有权系统：规则、移动语义与 Copy 特征
所有权是 Rust 最独特的特性和核心创新。Rust 中的每个值都有一个称为所有者的变量，当所有者超出作用域时，值会被自动丢弃（释放）。
三条所有权规则
- Rust 中的每个值都有一个称为其所有者的变量。
- 同一时刻只能有一个所有者。
- 当所有者超出作用域时，值将被丢弃。
fn main() {
// s1 owns the String
let s1 = String::from("hello");
// Ownership moves from s1 to s2
let s2 = s1;
// ERROR: s1 is no longer valid — it was moved
// println!("{}", s1); // error[E0382]: borrow of moved value: `s1`
// s2 is valid
println!("{}", s2); // "hello"
} // s2 is dropped here, memory is freed移动语义 vs 复制语义
堆分配类型如 String 和 Vec 默认会移动。只在栈上的类型（实现了 Copy 特征）则会被复制，原始变量仍然有效。
fn main() {
// i32 implements Copy — both variables are valid
let x = 5;
let y = x;
println!("x = {}, y = {}", x, y); // both work!
// String does NOT implement Copy — it moves
let s1 = String::from("world");
let s2 = s1; // s1 is moved into s2
// println!("{}", s1); // compile error!
// To keep both, use .clone()
let s3 = String::from("clone me");
let s4 = s3.clone(); // deep copy
println!("s3 = {}, s4 = {}", s3, s4); // both work
}
// Types that implement Copy: i32, f64, bool, char, tuples of Copy types
// Types that do NOT: String, Vec<T>, Box<T>, any type owning heap data借用与引用：&T、&mut T 与借用检查器
不转移所有权而是借用值，可以通过创建引用来实现。引用让你可以引用一个值而不取得它的所有权。
不可变引用 (&T)
fn calculate_length(s: &String) -> usize {
s.len()
}
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1); // borrow s1, don't move it
println!("Length of '{}' is {}.", s1, len);
// s1 is still valid!
// Multiple immutable borrows are fine
let r1 = &s1;
let r2 = &s1;
println!("{} and {}", r1, r2); // both valid simultaneously
}可变引用 (&mut T)
关键规则：同一时刻对同一数据只能有一个可变引用，且不能在同一作用域内混用可变和不可变引用。
fn change(some_string: &mut String) {
some_string.push_str(", world");
}
fn main() {
let mut s = String::from("hello");
change(&mut s);
println!("{}", s); // "hello, world"
// ERROR: Cannot have two mutable references at once
// let r1 = &mut s;
// let r2 = &mut s; // error[E0499]: cannot borrow `s` as mutable more than once
// NLL (Non-Lexical Lifetimes) — borrow ends at last use
let r3 = &s; // immutable borrow starts
let r4 = &s; // another immutable borrow
println!("{} and {}", r3, r4); // r3 and r4 last used here
// r3 and r4 are no longer active
let r5 = &mut s; // mutable borrow is now OK
r5.push_str("!");
}生命周期：'a、生命周期省略与 'static
生命周期是 Rust 确保引用在使用期间始终有效的方式。大多数情况下编译器可以自动推断生命周期（生命周期省略），但有时需要显式注解。
// Explicit lifetime annotation needed:
// Rust can't know if the return references x or y without 'a
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() { x } else { y }
}
// Lifetime in structs
struct Important<'a> {
part: &'a str, // part must live at least as long as Important
}
impl<'a> Important<'a> {
fn level(&self) -> usize { 3 }
}
// 'static lifetime — lives for the entire program
fn static_example() -> &'static str {
"I am always valid" // string literals are 'static
}
fn main() {
let string1 = String::from("long string");
let result;
{
let string2 = String::from("xyz");
result = longest(string1.as_str(), string2.as_str());
println!("Longest: {}", result); // OK — both strings live here
}
// println!("{}", result); // ERROR if uncommented — string2 dropped
}Structs 与 Enums：impl 块、方法与关联函数
#[derive(Debug, Clone)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
// Associated function (constructor) — Rectangle::new(30, 50)
fn new(width: u32, height: u32) -> Self {
Rectangle { width, height }
}
// Method — rect.area()
fn area(&self) -> u32 { self.width * self.height }
fn perimeter(&self) -> u32 { 2 * (self.width + self.height) }
fn can_hold(&self, other: &Rectangle) -> bool {
self.width > other.width && self.height > other.height
}
// Mutable method
fn scale(&mut self, factor: u32) {
self.width *= factor;
self.height *= factor;
}
}
// Enums with data
#[derive(Debug)]
enum Shape {
Circle(f64),
Rectangle(f64, f64),
Triangle { base: f64, height: f64 }, // named fields
}
impl Shape {
fn area(&self) -> f64 {
match self {
Shape::Circle(r) => std::f64::consts::PI * r * r,
Shape::Rectangle(w, h) => w * h,
Shape::Triangle { base, height } => 0.5 * base * height,
}
}
}
fn main() {
let mut r = Rectangle::new(30, 50);
println!("Area: {}, Perimeter: {}", r.area(), r.perimeter());
r.scale(2);
println!("Scaled: {:?}", r);
let shapes = vec![
Shape::Circle(5.0),
Shape::Rectangle(4.0, 6.0),
Shape::Triangle { base: 6.0, height: 4.0 },
];
for s in &shapes {
println!("{:?} => area {:.2}", s, s.area());
}
}模式匹配：match、if let、while let 与解构
fn describe_number(n: i32) -> &'static str {
match n {
0 => "zero",
1 | 2 | 3 => "small positive",
4..=9 => "medium",
10..=99 => "large",
n if n < 0 => "negative",
_ => "huge",
}
}
fn main() {
// Exhaustive matching — compiler forces all cases
let val: Option<i32> = Some(42);
// match
match val {
Some(n) if n > 100 => println!("Big: {}", n),
Some(n) => println!("Got: {}", n),
None => println!("Nothing"),
}
// if let — concise single-branch match
if let Some(n) = val {
println!("Shorthand: {}", n);
}
// while let — pop from stack until empty
let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
print!("{} ", top); // 3 2 1
}
println!();
// Destructuring tuples, structs
let point = (3, 7);
let (x, y) = point;
println!("x={}, y={}", x, y);
struct Pt { x: i32, y: i32 }
let p = Pt { x: 10, y: 20 };
let Pt { x, y } = p;
println!("x={}, y={}", x, y);
// @ bindings — bind while testing
let num = 15;
match num {
n @ 1..=12 => println!("Month: {}", n),
n @ 13..=19 => println!("Teen: {}", n),
n => println!("Other: {}", n),
}
}错误处理：Result<T, E>、Option<T>、? 运算符与自定义错误
Rust 没有异常。它使用 Result<T, E> 和 Option<T> 类型表示可能失败的操作，使错误处理显式且可组合。
use std::fs::File;
use std::io::{self, Read};
use std::num::ParseIntError;
use std::fmt;
// ? operator — propagates errors automatically
fn read_file(path: &str) -> Result<String, io::Error> {
let mut contents = String::new();
File::open(path)?.read_to_string(&mut contents)?;
Ok(contents)
}
// Custom error type
#[derive(Debug)]
enum AppError {
Parse(ParseIntError),
OutOfRange(i32),
}
impl fmt::Display for AppError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
AppError::Parse(e) => write!(f, "parse error: {}", e),
AppError::OutOfRange(n) => write!(f, "{} is out of valid range", n),
}
}
}
// From trait enables automatic conversion with ?
impl From<ParseIntError> for AppError {
fn from(e: ParseIntError) -> Self { AppError::Parse(e) }
}
fn validate_age(s: &str) -> Result<u8, AppError> {
let age: i32 = s.trim().parse()?; // ParseIntError -> AppError via From
if !(0..=150).contains(&age) {
return Err(AppError::OutOfRange(age));
}
Ok(age as u8)
}
fn main() {
// unwrap_or, unwrap_or_else, map, and_then
let age = validate_age("25").unwrap_or(0);
let doubled = validate_age("21").map(|a| a * 2).unwrap_or(0);
// and_then chains Results
let result = validate_age("30")
.and_then(|a| if a > 18 { Ok(a) } else { Err(AppError::OutOfRange(a as i32)) });
for input in &["25", "-5", "200", "abc"] {
match validate_age(input) {
Ok(a) => println!("Valid age: {}", a),
Err(e) => println!("Error for {:?}: {}", input, e),
}
}
}特征（Traits）：定义、实现、特征对象与泛型
use std::fmt::Display;
trait Summary {
fn summarize_author(&self) -> String; // required
fn summarize(&self) -> String { // default implementation
format!("(Read more from {}...)", self.summarize_author())
}
}
struct Article {
title: String,
author: String,
content: String,
}
impl Summary for Article {
fn summarize_author(&self) -> String { self.author.clone() }
fn summarize(&self) -> String {
format!("{}, by {} — {}", self.title, self.author, &self.content[..50])
}
}
// Trait bounds — static dispatch (monomorphization, zero overhead)
fn notify<T: Summary + Display>(item: &T) {
println!("Breaking news! {}", item.summarize());
}
// Where clause for readability
fn complex<T, U>(t: &T, u: &U)
where
T: Summary + Clone,
U: Summary + std::fmt::Debug,
{
println!("{} {}", t.summarize(), u.summarize());
}
// Trait objects — dynamic dispatch (runtime polymorphism)
fn notify_all(items: &[Box<dyn Summary>]) {
for item in items {
println!("{}", item.summarize());
}
}
// Returning trait objects
fn make_summarizable(is_article: bool) -> Box<dyn Summary> {
if is_article {
Box::new(Article {
title: String::from("Rust Is Amazing"),
author: String::from("Ferris"),
content: String::from("Rust achieves memory safety without GC..."),
})
} else {
// Some other type implementing Summary
Box::new(Article {
title: String::from("Default"),
author: String::from("Anonymous"),
content: String::from("Content here..."),
})
}
}迭代器与闭包：map、filter、collect 与链式调用
fn main() {
let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// Lazy iterator chain — no work until consumed
let sum: i32 = numbers
.iter()
.filter(|&&x| x % 2 == 0) // keep evens: 2,4,6,8,10
.map(|&x| x * x) // square: 4,16,36,64,100
.sum(); // consume: 220
println!("Sum of even squares: {}", sum);
// Collect into Vec
let strings: Vec<String> = (1..=5)
.map(|n| format!("item_{}", n))
.collect();
println!("{:?}", strings);
// zip — pair two iterators
let names = vec!["Alice", "Bob", "Charlie"];
let scores = vec![95, 87, 91];
let paired: Vec<_> = names.iter().zip(scores.iter()).collect();
println!("{:?}", paired);
// flat_map
let sentences = vec!["hello world", "foo bar"];
let words: Vec<&str> = sentences.iter()
.flat_map(|s| s.split_whitespace())
.collect();
println!("{:?}", words);
// fold — general accumulator
let product: i32 = (1..=5).fold(1, |acc, x| acc * x);
println!("5! = {}", product);
// Closures capturing environment
let threshold = 5;
let above_threshold: Vec<_> = numbers.iter()
.filter(|&&x| x > threshold) // captures threshold
.collect();
println!("{:?}", above_threshold);
// Custom iterator with take_while and skip_while
let partitioned: Vec<_> = numbers.iter()
.skip_while(|&&x| x < 3) // skip until x >= 3
.take_while(|&&x| x < 8) // take until x >= 8
.collect();
println!("{:?}", partitioned); // [3, 4, 5, 6, 7]
}Cargo 与 Crates：Cargo.toml、crates.io 与工作区
# Cargo.toml — project manifest
[package]
name = "my_app"
version = "0.1.0"
edition = "2021"
description = "My awesome Rust application"
license = "MIT OR Apache-2.0"
[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }
anyhow = "1.0"
clap = { version = "4", features = ["derive"] }
log = "0.4"
env_logger = "0.10"
[dev-dependencies]
criterion = "0.5"
[profile.release]
opt-level = 3
lto = true
codegen-units = 1
# Workspace Cargo.toml (monorepo)
# [workspace]
# members = ["app", "core-lib", "api-types"]
# resolver = "2"# Key Cargo commands
cargo new my_project # new binary project
cargo new my_lib --lib # new library project
cargo init # init in existing directory
cargo build # debug build (fast compile)
cargo build --release # optimized build
cargo run -- --arg value # build and run with args
cargo test # run all tests
cargo test my_test_name # run specific test
cargo test -- --nocapture # show stdout from tests
cargo bench # run benchmarks
cargo doc --open # generate + open docs
cargo fmt # format code (rustfmt)
cargo clippy # lint with Clippy
cargo check # type-check without compiling
cargo add serde --features derive # add dependency
cargo update # update Cargo.lock标准库：Vec、HashMap、String vs &str 与 Box<T>
use std::collections::HashMap;
fn main() {
// ============ String vs &str ============
let literal: &str = "static string"; // &str — immutable slice, stack
let owned: String = String::from("heap string"); // String — heap, mutable
let also_owned: String = "convert".to_string();
let slice: &str = &owned; // String to &str via deref coercion
// String operations
let mut s = String::new();
s.push_str("hello");
s.push(' ');
s += "world";
let upper = s.to_uppercase();
let words: Vec<&str> = s.split_whitespace().collect();
let contains_hello = s.contains("hello");
let replaced = s.replace("world", "Rust");
// ============ Vec<T> ============
let mut v: Vec<i32> = vec![3, 1, 4, 1, 5, 9, 2, 6];
v.push(7);
v.extend([8, 10]);
v.sort();
v.dedup();
v.retain(|&x| x > 3);
let sum: i32 = v.iter().sum();
let safe_get: Option<&i32> = v.get(100); // None, not panic
// ============ HashMap<K, V> ============
let mut map: HashMap<&str, Vec<i32>> = HashMap::new();
map.entry("alice").or_insert_with(Vec::new).push(95);
map.entry("alice").or_insert_with(Vec::new).push(87);
map.entry("bob").or_insert_with(Vec::new).push(91);
for (name, scores) in &map {
let avg: f64 = scores.iter().sum::<i32>() as f64 / scores.len() as f64;
println!("{}: avg {:.1}", name, avg);
}
// ============ Box<T> — heap allocation ============
let boxed: Box<i32> = Box::new(42);
println!("Boxed: {}", *boxed); // deref coercion
// Box enables recursive types
enum Tree {
Leaf(i32),
Node(Box<Tree>, Box<Tree>),
}
let tree = Tree::Node(
Box::new(Tree::Leaf(1)),
Box::new(Tree::Leaf(2)),
);
}并发：线程、Arc、Mutex 与通道
Rust 的所有权系统在编译时防止数据竞争。类型系统确保对共享状态的不安全并发访问在没有显式同步的情况下是不可能的。
use std::sync::{Arc, Mutex};
use std::thread;
use std::sync::mpsc;
fn main() {
// ============ Basic threads ============
let handle = thread::spawn(|| {
println!("Hello from spawned thread!");
});
handle.join().unwrap();
// move closure — take ownership of captured values
let data = vec![1, 2, 3];
let handle = thread::spawn(move || {
println!("Thread has data: {:?}", data);
});
handle.join().unwrap();
// ============ Arc<Mutex<T>> — shared mutable state ============
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
let c = Arc::clone(&counter);
let h = thread::spawn(move || {
let mut num = c.lock().unwrap(); // blocks until lock acquired
*num += 1;
}); // lock released automatically when num goes out of scope
handles.push(h);
}
for h in handles { h.join().unwrap(); }
println!("Counter: {}", *counter.lock().unwrap()); // 10
// ============ Message passing with channels ============
let (tx, rx) = mpsc::channel::<String>();
let tx2 = tx.clone();
thread::spawn(move || {
tx.send(String::from("Message from thread 1")).unwrap();
});
thread::spawn(move || {
tx2.send(String::from("Message from thread 2")).unwrap();
});
// rx is an iterator over received values
for _ in 0..2 {
let msg = rx.recv().unwrap(); // blocks until message arrives
println!("Received: {}", msg);
}
}Rust vs C++ vs Go 对比
Rust 在系统编程领域占据独特位置。以下是与两种最常见替代品的比较：
| 特性 | Rust | C++ | Go |
|---|---|---|---|
| 内存管理 | 所有权（编译时） | 手动 + RAII | 垃圾回收 |
| 内存安全 | 强（编译时保证） | 弱（程序员负责） | 强（GC 保证） |
| 性能 | 极快（媲美 C） | 极快（C 级别） | 快（GC 暂停） |
| 并发 | 编译时数据竞争预防 | 不安全（无保证） | Goroutines（运行时调度） |
| 学习曲线 | 陡峭（借用检查器） | 非常陡峭 | 平缓 |
| 编译速度 | 慢（增量编译可改善） | 慢（取决于模板） | 极快 |
| 包管理 | Cargo（优秀） | 无官方（vcpkg/conan） | Go modules（内置） |
| 空安全 | Option<T>（无 null） | 无（std::optional 可选） | 无（nil 存在） |
| 异常处理 | Result<T,E>（显式） | 异常（throw/catch） | 多返回值（error 接口） |
| 适用场景 | OS、嵌入式、WebAssembly、CLI | 游戏引擎、驱动、高性能 | 微服务、网络、DevOps 工具 |
常见问题解答（FAQ）
What makes Rust different from C and C++?
Rust provides memory safety guarantees at compile time through its ownership system, eliminating entire categories of bugs like null pointer dereferences, use-after-free, and data races — without needing a garbage collector. C and C++ rely on programmer discipline for memory safety, while Rust enforces it automatically.
Is Rust hard to learn?
Rust has a steeper learning curve than Go or Python, primarily because of the ownership and borrow checker concepts. However, most developers report that once these concepts click, they become second nature. The Rust Book (doc.rust-lang.org/book) and the Rustlings exercises are excellent free learning resources.
When should I use Rust vs Go?
Use Rust when you need maximum performance, low-level control, or safety-critical systems — OS kernels, embedded systems, game engines, or WebAssembly. Use Go when you need fast development cycles, simple concurrency, and network services — microservices, CLI tools, DevOps utilities.
What is the borrow checker in Rust?
The borrow checker is the Rust compiler component that enforces ownership rules at compile time. It ensures that: (1) references don't outlive the data they refer to, (2) you don't have both mutable and immutable references simultaneously, and (3) there's at most one mutable reference at a time. This eliminates memory bugs without runtime overhead.
What is async/await in Rust?
Rust supports async/await syntax for writing asynchronous code. The async keyword transforms a function into one returning a Future. The await keyword suspends execution until a Future is resolved. Rust does not include an async runtime by default — you typically use Tokio or async-std. Unlike Go, Rust async is zero-cost and does not require separate OS threads.
What is Rust used for in production?
Rust is used in production for: systems programming (OS components, drivers), WebAssembly (Figma, game engines), networking (Cloudflare workers, AWS Firecracker), databases (TiKV, Neon), CLI tools (ripgrep, fd, bat, exa), game development (Bevy engine), and embedded systems. Major adopters include Microsoft, Google, Amazon, Meta, Discord, and Dropbox.
How does Rust handle null values?
Rust has no null keyword. Instead, it uses the Option<T> enum with two variants: Some(T) when a value exists, and None when it does not. This forces you to explicitly handle the absence of a value, eliminating null pointer dereferences entirely. You handle Option using match, if let, unwrap_or, map, and the ? operator.
What is cargo and how do I use it?
Cargo is the official Rust build tool and package manager. Key commands: cargo new project_name (create project), cargo build (compile), cargo run (compile and run), cargo test (run tests), cargo add crate_name (add dependency), cargo doc --open (generate docs), cargo publish (publish to crates.io). Dependencies are declared in Cargo.toml and automatically downloaded from crates.io.
总结：Rust 值得学习吗？
Rust 不仅仅是另一门系统编程语言——它代表了软件工程的范式转变。通过在编译时而非运行时强制保证内存安全和线程安全，Rust 让开发者能够编写出其他语言难以实现的既安全又高效的代码。
学习曲线确实存在，主要体现在理解借用检查器上。但一旦你内化了所有权模型，你会发现它不仅能防止错误，还能帮助你更清晰地思考程序的结构和数据流。Rust 的编译器错误是出了名的有帮助，常常直接告诉你如何修复问题。
如果你在 C++ 中遇到内存安全问题，在 Go 中遇到性能瓶颈，或者在构建任何需要可靠、高效和并发的系统——Rust 是你值得认真考虑的选择。
学习资源
- The Rust Book —
doc.rust-lang.org/book（官方免费教程，最佳入门资料） - Rustlings —
github.com/rust-lang/rustlings（小型互动练习） - Rust by Example —
doc.rust-lang.org/rust-by-example（代码示例学习） - The Rustonomicon — （unsafe Rust 的黑暗艺术）
- crates.io — （Rust 的包注册中心）
- Rust Playground —
play.rust-lang.org（浏览器中运行 Rust）