不可变引用 &T
核心概念
不可变引用 &T 是 Rust 中最常用的引用形式,它允许你读取数据但不能修改数据。不可变引用本身是 Copy 的——复制引用只是复制指针,不复制数据。在同一时间可以存在任意数量的不可变引用,这让多处代码能同时安全地读取同一份数据。
fn main() {
let s = String::from("hello");
// 创建不可变引用
let r1 = &s;
let r2 = &s;
let r3 = &s;
// 多个不可变引用同时存在,完全合法
println!("{}, {}, {}", r1, r2, r3);
// 通过引用不能修改数据
// r1.push_str(" world"); // 编译错误
// 原始变量仍然有效
println!("原始: {}", s);
}不可变引用作为函数参数
函数参数使用 &T 是最常见的数据传递方式——读取数据但不获取所有权。
// 接受 String 的不可变引用
fn string_info(s: &String) {
println!("内容: '{}', 长度: {}, 容量: {}", s, s.len(), s.capacity());
}
// 接受字符串切片(更通用)
fn word_count(text: &str) -> usize {
text.split_whitespace().count()
}
// 接受 Vec 的不可变引用
fn sum_of(numbers: &Vec<i32>) -> i32 {
numbers.iter().sum()
}
// 接受切片引用(更通用)
fn average(data: &[f64]) -> f64 {
if data.is_empty() {
return 0.0;
}
let total: f64 = data.iter().sum();
total / data.len() as f64
}
fn main() {
let s = String::from("hello world foo bar");
string_info(&s);
println!("单词数: {}", word_count(&s));
println!("s 仍然有效: {}", s);
let nums = vec![10, 20, 30, 40];
println!("总和: {}", sum_of(&nums));
let scores = vec![85.0, 92.5, 78.0, 95.0, 88.5];
println!("平均分: {:.1}", average(&scores));
println!("scores 仍然有效: {:?}", scores);
}自动解引用 Deref
Rust 的自动解引用(Deref coercion)让引用的使用非常自然——在很多地方你不需要手动解引用。
fn main() {
let s = String::from("Hello, Rust!");
let r: &String = &s;
// 自动解引用:通过 &String 直接调用 String 的方法
println!("长度: {}", r.len()); // 等同于 (*r).len()
println!("大写: {}", r.to_uppercase());
println!("包含: {}", r.contains("Rust"));
// Deref coercion:&String 自动转为 &str
let r2: &str = &s; // String → &str(通过 Deref)
println!("切片: {}", r2);
// 多层引用也能自动解引用
let r3 = &&&&s;
println!("多层引用: {}", r3.len()); // 自动解引用到 String
// 比较运算也自动解引用
let a = String::from("hello");
let b = String::from("hello");
assert_eq!(&a, &b); // 比较的是内容,不是地址
}&String vs &str
函数参数推荐使用 &str 而不是 &String,因为 &str 更通用。
// 不推荐:只接受 &String
fn greet_string(name: &String) {
println!("你好, {}!", name);
}
// 推荐:接受 &str,更通用
fn greet_str(name: &str) {
println!("你好, {}!", name);
}
fn main() {
let owned = String::from("张三");
let literal = "李四";
let slice = &owned[..2];
// &String 版本只能接受 &String
greet_string(&owned);
// greet_string(literal); // 编译错误:类型不匹配
// greet_string(slice); // 编译错误
// &str 版本都能接受
greet_str(&owned); // &String 自动 Deref 为 &str
greet_str(literal); // &str 直接传
greet_str(slice); // &str 直接传
}| 参数类型 | 能接受 &String | 能接受 &str | 能接受字面量 | 推荐度 |
|---|---|---|---|---|
&String | 能 | 不能 | 不能 | 不推荐 |
&str | 能(自动 Deref) | 能 | 能 | 推荐 |
同理:
| 参数类型 | 能接受 &Vec | 能接受 &[T] | 推荐度 |
|---|---|---|---|
&Vec<T> | 能 | 不能 | 不推荐 |
&[T] | 能(自动 Deref) | 能 | 推荐 |
引用的生命周期
不可变引用不能超过被引用数据的生命周期。
fn main() {
// 正确:引用在数据有效范围内
let s = String::from("hello");
let r = &s;
println!("{}", r);
// 错误示例(无法编译):
// let r;
// {
// let s = String::from("hello");
// r = &s; // s 在这个块结束时被销毁
// }
// println!("{}", r); // r 成了悬垂引用
// 正确:返回输入的引用
let s1 = String::from("hello");
let s2 = String::from("hi");
let longer = longest(&s1, &s2);
println!("更长: {}", longer);
}
fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
if a.len() > b.len() { a } else { b }
}基本示例
用不可变引用实现一个学生成绩查询系统:
#[derive(Debug)]
struct Student {
name: String,
scores: Vec<(String, f64)>, // (科目, 分数)
}
impl Student {
fn new(name: &str) -> Self {
Student {
name: name.to_string(),
scores: Vec::new(),
}
}
fn add_score(&mut self, subject: &str, score: f64) {
self.scores.push((subject.to_string(), score));
}
}
// 以下函数全部使用不可变引用,不影响原数据
fn get_average(student: &Student) -> f64 {
if student.scores.is_empty() {
return 0.0;
}
let total: f64 = student.scores.iter().map(|(_, s)| s).sum();
total / student.scores.len() as f64
}
fn get_highest(student: &Student) -> Option<(&str, f64)> {
student.scores.iter()
.max_by(|a, b| a.1.partial_cmp(&b.1).unwrap())
.map(|(subj, score)| (subj.as_str(), *score))
}
fn get_lowest(student: &Student) -> Option<(&str, f64)> {
student.scores.iter()
.min_by(|a, b| a.1.partial_cmp(&b.1).unwrap())
.map(|(subj, score)| (subj.as_str(), *score))
}
fn is_pass(student: &Student, threshold: f64) -> bool {
student.scores.iter().all(|(_, s)| *s >= threshold)
}
fn print_report(student: &Student) {
println!("\n=== {} 的成绩单 ===", student.name);
for (subject, score) in &student.scores {
let grade = match *score as u32 {
90..=100 => "优秀",
80..=89 => "良好",
70..=79 => "中等",
60..=69 => "及格",
_ => "不及格",
};
println!(" {}: {:.1} ({})", subject, score, grade);
}
println!(" 平均分: {:.1}", get_average(student));
if let Some((subj, score)) = get_highest(student) {
println!(" 最高: {} ({:.1})", subj, score);
}
if let Some((subj, score)) = get_lowest(student) {
println!(" 最低: {} ({:.1})", subj, score);
}
println!(" 全部及格: {}", if is_pass(student, 60.0) { "是" } else { "否" });
}
// 比较两个学生的平均分
fn compare_students(a: &Student, b: &Student) {
let avg_a = get_average(a);
let avg_b = get_average(b);
println!("\n{} 平均 {:.1} vs {} 平均 {:.1}",
a.name, avg_a, b.name, avg_b);
if avg_a > avg_b {
println!("{} 的平均分更高", a.name);
} else if avg_b > avg_a {
println!("{} 的平均分更高", b.name);
} else {
println!("两人平均分相同");
}
}
fn main() {
let mut alice = Student::new("Alice");
alice.add_score("数学", 95.0);
alice.add_score("语文", 88.0);
alice.add_score("英语", 92.0);
let mut bob = Student::new("Bob");
bob.add_score("数学", 78.0);
bob.add_score("语文", 85.0);
bob.add_score("英语", 55.0);
// 多次不可变借用:同时传两个引用
print_report(&alice);
print_report(&bob);
compare_students(&alice, &bob);
// 原数据始终有效
println!("\nAlice 的科目数: {}", alice.scores.len());
println!("Bob 的科目数: {}", bob.scores.len());
}常见问题
问题一:不可变引用的大小是多少?
普通引用 &T 是一个指针大小(64 位系统上 8 字节)。胖引用(&[T]、&str、&dyn Trait)是两个指针大小(16 字节),包含数据指针和元数据(长度或 vtable)。
问题二:不可变引用存在时能移动原值吗?
不能。不可变引用存在期间,被引用的值不能被移动或销毁,因为这会导致引用悬垂。
fn main() {
let s = String::from("hello");
let r = &s;
// let s2 = s; // 编译错误:s 被借用中,不能移动
println!("{}", r);
// r 不再使用后(NLL),s 可以被移动
let s2 = s;
println!("{}", s2);
}问题三:引用可以存储在结构体中吗?
可以,但需要标注生命周期,保证引用不会超过被引用数据的生命周期。
struct Excerpt<'a> {
text: &'a str, // 存储引用,需要生命周期标注
}
fn main() {
let novel = String::from("很久以前。有一个国王。");
let excerpt = Excerpt { text: &novel[..12] };
println!("摘录: {}", excerpt.text);
}问题四:&T 是线程安全的吗?
&T 是 Send 和 Sync 的(只要 T 是 Sync 的),可以安全地在线程之间共享。多个线程同时只读地访问同一数据是安全的。
适用场景
- 函数参数:只需要读取数据时传
&T或&str/&[T] - 多处共享:多个变量或函数同时读取同一数据
- 结构体字段:存储对外部数据的引用(需要生命周期标注)
- 方法 &self:不修改对象状态的方法
注意事项
- 不可变引用不能修改被引用的数据
- 多个不可变引用可以同时存在
- 不可变引用存在时不能创建可变引用
- 不可变引用本身是 Copy 的
- 函数参数优先用
&str而不是&String - 函数参数优先用
&[T]而不是&Vec<T> - 引用不能超过被引用值的生命周期
总结
不可变引用 &T 允许读取数据而不获取所有权,是 Rust 中使用最频繁的引用形式。它的核心特点是:可以同时存在任意数量的不可变引用,但不能通过不可变引用修改数据。函数参数推荐使用更通用的切片形式(&str 代替 &String、&[T] 代替 &Vec<T>)。不可变引用本身是 Copy 的,复制引用不复制数据。Rust 的自动解引用机制让使用引用的体验和直接使用值几乎一样自然。