Rust从入门到实战系列二百七十九：方法和关联函数

示例
struct Point {
x: f64,
y: f64,
}
// Point 的 关 联 函 数 都 放 在 下 面 的 impl 语 句 块 中
impl Point {
// 关 联 函 数 的 使 用 方 法 跟 构 造 器 非 常 类 似
fn origin() -> Point {
Point { x: 0.0, y: 0.0 }
}
// 另 外 一 个 关 联 函 数 ， 有 两 个 参 数
fn new(x: f64, y: f64) -> Point {
Point { x: x, y: y }
}
}
struct Rectangle {
p1: Point,
p2: Point,
}
impl Rectangle {
// 这 是 一 个 方 法
// &self 是 self: &Self 的 语 法 糖
// Self 是 当 前 调 用 对 象 的 类 型 ， 对 于 本 例 来 说 Self = Rectangle
fn area(&self) -> f64 {
// 使 用 点 操 作 符 可 以 访 问 self 中 的 结 构 体 字 段
let Point { x: x1, y: y1 } = self.p1;
let Point { x: x2, y: y2 } = self.p2;
// abs 是 一 个 f64 类 型 的 方 法 ， 会 返 回 调 用 者 的 绝 对 值
((x1 - x2) * (y1 - y2)).abs()
}
fn perimeter(&self) -> f64 {
let Point { x: x1, y: y1 } = self.p1;
let Point { x: x2, y: y2 } = self.p2;
2.0 * ((x1 - x2).abs() + (y1 - y2).abs())
}
// 该 方 法 要 求 调 用 者 是 可 变 的 ，&mut self 是 self: &mut Self 的 语 法 糖
fn translate(&mut self, x: f64, y: f64) {
self.p1.x += x;
self.p2.x += x;
self.p1.y += y;
self.p2.y += y;
}
}
// Pair 持 有 两 个 分 配 在 堆 上 的 整 数
struct Pair(Box, Box);
impl Pair {
// 该 方 法 会 拿 走 调 用 者 的 所 有 权
// self 是 self: Self 的 语 法 糖
fn destroy(self) {
let Pair(first, second) = self;
println!(“Destroying Pair({}, {})”, first, second);
// first 和 second 在 这 里 超 出 作 用 域 并 被 释 放
}
}
fn main() {
a () {
let rectangle = Rectangle {
// 关 联 函 数 的 调 用 不 是 通 过 点 操 作 符 ， 而 是 使 用 ::
p1: Point::origin(),
p2: Point::new(3.0, 4.0),
};
// 方 法 才 是 通 过 点 操 作 符 调 用
// 注 意 ， 这 里 的 方 法 需 要 的 是 &self 但 是 我 们 并 没 有 使 用 (&rectangle).perimeter() 来 调
// 编 译 器 会 帮 我 们 自 动 取 引 用
// rectangle.perimeter() === Rectangle::perimeter(&rectangle)
println!(“Rectangle perimeter: {}”, rectangle.perimeter());
println!(“Rectangle area: {}”, rectangle.area());
let mut square = Rectangle {
p1: Point::origin(),
p2: Point::new(1.0, 1.0),
};
// 错 误 ！rectangle 是 不 可 变 的 ， 但 是 这 个 方 法 要 求 一 个 可 变 的 对 象
//rectangle.translate(1.0, 0.0);
// TODO ^ 试 着 反 注 释 此 行 ， 看 看 会 发 生 什 么
// 可 以 ！ 可 变 对 象 可 以 调 用 可 变 的 方 法
square.translate(1.0, 1.0);
let pair = Pair(Box::new(1), Box::new(2));
pair.destroy();
// Error! 上 一 个 destroy 调 用 拿 走 了 pair 的 所 有 权
//pair.destroy();
// TODO ^ 试 着 反 注 释 此 行
}