&self 不可变方法 ​

核心概念 ​

&self 方法通过不可变引用借用实例,只能读取字段的值而不能修改它们。这是最常用的方法形式——大多数方法只需要读取数据进行计算或查询,不需要改变实例的状态。调用 &self 方法后,实例仍然可以继续使用,因为只是借用了引用。

rust
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 的简写 ​

rust
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 绑定。

rust
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 方法的返回值可以同时存在。

rust
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 方法实现一个统计分析器:

rust
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 方法的返回引用可以同时存在而不会冲突。