&self 不可变方法
核心概念
&self 方法通过不可变引用借用实例,只能读取字段的值而不能修改它们。这是最常用的方法形式——大多数方法只需要读取数据进行计算或查询,不需要改变实例的状态。调用 &self 方法后,实例仍然可以继续使用,因为只是借用了引用。
struct Circle {
radius: f64,
}
impl Circle {
fn new(radius: f64) -> Self {
Circle { radius }
}
// &self 方法:只读取 radius,不修改
fn area(&self) -> f64 {
std::f64::consts::PI * self.radius * self.radius
}
// &self 方法:只读取 radius,不修改
fn circumference(&self) -> f64 {
2.0 * std::f64::consts::PI * self.radius
}
// &self 方法:返回布尔值
fn is_unit_circle(&self) -> bool {
(self.radius - 1.0).abs() < f64::EPSILON
}
}
fn main() {
let c = Circle::new(5.0);
// 调用多次 &self 方法,实例不受影响
println!("面积: {:.2}", c.area());
println!("周长: {:.2}", c.circumference());
println!("单位圆: {}", c.is_unit_circle());
// c 仍然可以使用
println!("半径: {}", c.radius);
}&self 是 self: &Self 的简写
struct Point {
x: f64,
y: f64,
}
impl Point {
fn new(x: f64, y: f64) -> Self {
Point { x, y }
}
// 以下两种写法完全等价
fn distance_short(&self, other: &Point) -> f64 {
((self.x - other.x).powi(2) + (self.y - other.y).powi(2)).sqrt()
}
// 完整写法(很少用,但有助于理解)
fn distance_long(self: &Self, other: &Point) -> f64 {
((self.x - other.x).powi(2) + (self.y - other.y).powi(2)).sqrt()
}
}
fn main() {
let p1 = Point::new(0.0, 0.0);
let p2 = Point::new(3.0, 4.0);
println!("距离: {:.2}", p1.distance_short(&p2));
println!("距离: {:.2}", p1.distance_long(&p2));
}返回引用的 &self 方法
&self 方法可以返回指向自身字段的引用,返回引用的生命周期和 &self 绑定。
struct Student {
name: String,
scores: Vec<u32>,
}
impl Student {
fn new(name: &str) -> Self {
Student {
name: name.to_string(),
scores: Vec::new(),
}
}
// 返回 &str:生命周期和 &self 相同
fn name(&self) -> &str {
&self.name
}
// 返回 &[u32]:切片引用
fn scores(&self) -> &[u32] {
&self.scores
}
// 返回 Option<&u32>
fn highest_score(&self) -> Option<&u32> {
self.scores.iter().max()
}
fn average(&self) -> f64 {
if self.scores.is_empty() {
return 0.0;
}
let sum: u32 = self.scores.iter().sum();
sum as f64 / self.scores.len() as f64
}
fn is_passing(&self) -> bool {
self.scores.iter().all(|&s| s >= 60)
}
fn score_count(&self) -> usize {
self.scores.len()
}
}
fn main() {
let mut s = Student::new("张三");
s.scores = vec![85, 92, 78, 95, 88];
// 所有 &self 方法调用后实例仍可用
println!("姓名: {}", s.name());
println!("成绩: {:?}", s.scores());
println!("最高分: {:?}", s.highest_score());
println!("平均分: {:.1}", s.average());
println!("全部及格: {}", s.is_passing());
println!("成绩数: {}", s.score_count());
}多个 &self 方法的并行借用
因为 &self 是不可变借用,多个 &self 方法的返回值可以同时存在。
struct Config {
host: String,
port: u16,
debug: bool,
}
impl Config {
fn new(host: &str, port: u16) -> Self {
Config {
host: host.to_string(),
port,
debug: false,
}
}
fn host(&self) -> &str {
&self.host
}
fn port(&self) -> u16 {
self.port
}
fn is_debug(&self) -> bool {
self.debug
}
fn address(&self) -> String {
format!("{}:{}", self.host, self.port)
}
}
fn main() {
let config = Config::new("localhost", 8080);
// 多个不可变引用可以同时存在
let host = config.host();
let port = config.port();
let addr = config.address();
// 全部可以同时使用
println!("主机: {}, 端口: {}, 地址: {}", host, port, addr);
}基本示例
用 &self 方法实现一个统计分析器:
struct DataSet {
name: String,
values: Vec<f64>,
}
impl DataSet {
fn new(name: &str, values: Vec<f64>) -> Self {
DataSet {
name: name.to_string(),
values,
}
}
fn name(&self) -> &str {
&self.name
}
fn count(&self) -> usize {
self.values.len()
}
fn is_empty(&self) -> bool {
self.values.is_empty()
}
fn sum(&self) -> f64 {
self.values.iter().sum()
}
fn mean(&self) -> Option<f64> {
if self.is_empty() {
return None;
}
Some(self.sum() / self.count() as f64)
}
fn min(&self) -> Option<f64> {
self.values.iter().cloned().reduce(f64::min)
}
fn max(&self) -> Option<f64> {
self.values.iter().cloned().reduce(f64::max)
}
fn range(&self) -> Option<f64> {
match (self.min(), self.max()) {
(Some(min), Some(max)) => Some(max - min),
_ => None,
}
}
// 方差
fn variance(&self) -> Option<f64> {
let mean = self.mean()?;
let sum_sq: f64 = self.values.iter()
.map(|v| (v - mean).powi(2))
.sum();
Some(sum_sq / self.count() as f64)
}
// 标准差
fn std_dev(&self) -> Option<f64> {
self.variance().map(|v| v.sqrt())
}
// 中位数
fn median(&self) -> Option<f64> {
if self.is_empty() {
return None;
}
let mut sorted = self.values.clone();
sorted.sort_by(|a, b| a.partial_cmp(b).unwrap());
let mid = sorted.len() / 2;
if sorted.len() % 2 == 0 {
Some((sorted[mid - 1] + sorted[mid]) / 2.0)
} else {
Some(sorted[mid])
}
}
fn report(&self) {
println!("\n=== {} 统计报告 ===", self.name());
println!("数据量: {}", self.count());
if let Some(mean) = self.mean() {
println!("均值: {:.2}", mean);
}
if let Some(median) = self.median() {
println!("中位数: {:.2}", median);
}
if let Some(min) = self.min() {
println!("最小值: {:.2}", min);
}
if let Some(max) = self.max() {
println!("最大值: {:.2}", max);
}
if let Some(range) = self.range() {
println!("极差: {:.2}", range);
}
if let Some(std_dev) = self.std_dev() {
println!("标准差: {:.2}", std_dev);
}
}
}
fn main() {
let scores = DataSet::new(
"考试成绩",
vec![72.0, 85.0, 90.0, 68.0, 95.0, 78.0, 88.0, 92.0],
);
scores.report();
let temps = DataSet::new(
"本周温度",
vec![22.5, 25.0, 28.3, 30.1, 27.8, 24.6, 23.2],
);
temps.report();
let empty = DataSet::new("空数据集", vec![]);
empty.report();
}常见问题
问题一:&self 方法能修改字段吗?
不能。&self 是不可变借用,编译器不允许通过它修改任何字段。需要修改字段时用 &mut self。但如果字段类型使用了内部可变性(如 Cell、RefCell),可以在 &self 方法中修改。
问题二:什么时候该用 &self?
绝大多数方法都应该用 &self——只要方法不需要修改实例的状态就用 &self。getter 方法、计算方法、查询方法、格式化方法都应该用 &self。
问题三:&self 方法的返回值可以是什么类型?
任何类型都可以。返回拥有所有权的值(String、Vec<T>)、Copy 类型(i32、f64、bool)、引用(&str、&[T])、Option、Result 等都可以。
问题四:多个 &self 方法可以链式调用吗?
如果方法返回 &Self(自身引用),可以链式调用。但大多数 &self 方法返回的是计算结果而不是 &Self,所以链式调用不常见(链式调用更多用在 &mut self 方法中)。
适用场景
- getter 方法:获取字段值(
fn name(&self) -> &str) - 计算方法:基于字段进行计算(
fn area(&self) -> f64) - 查询方法:检查状态(
fn is_empty(&self) -> bool) - 格式化方法:生成显示文本(
fn summary(&self) -> String)
注意事项
&self是self: &Self的简写&self方法不能修改任何字段- 调用
&self方法后实例仍然可以使用 - 多个
&self方法的返回引用可以同时存在 - 绝大多数方法都应该用
&self - 返回字段引用时,生命周期自动和
&self关联
总结
&self 方法通过不可变引用借用实例,是最常用的方法形式。它只能读取字段值,不能修改实例状态。调用后实例不受影响,可以继续使用。getter、计算、查询、格式化等不需要修改数据的方法都应该用 &self。返回字段引用的 &self 方法,其返回值的生命周期自动和 self 绑定。由于是不可变借用,多个 &self 方法的返回引用可以同时存在而不会冲突。