方法语法

方法类似于函数：我们使用 fn 关键字和名称来声明它们，它们可以有参数和返回值，并且它们包含一些在其他地方调用方法时运行的代码。与函数不同，方法是在结构体（或枚举或 trait 对象，我们在 第 6 章和 第 17 章中讨论）的上下文中定义的，并且它们的第一个参数始终是 self，它表示调用方法的结构体的实例。

定义方法

让我们更改 area 函数，该函数有一个 Rectangle 实例作为参数，而是将 area 方法定义在 Rectangle 结构体上，如示例 5-13 所示。

文件名：src/main.rs 
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );
}
示例 5-13：在 Rectangle 结构体上定义 area 方法

为了在 Rectangle 的上下文中定义函数，我们为 Rectangle 启动一个 impl（实现）块。这个 impl 块中的所有内容都将与 Rectangle 类型关联。然后我们将 area 函数移动到 impl 花括号内，并将第一个（在本例中是唯一一个）参数更改为签名和主体中的所有位置都是 self。在 main 中，我们调用了 area 函数并传递了 rect1 作为参数，我们可以改为使用方法语法在我们的 Rectangle 实例上调用 area 方法。方法语法在实例之后：我们添加一个点，后跟方法名称、括号和任何参数。

在 area 的签名中，我们使用 &self 而不是 rectangle: &Rectangle。&self 实际上是 self: &Self 的简写。在 impl 块中，类型 Self 是 impl 块所针对的类型的别名。方法必须有一个名为 self 的参数，类型为 Self，作为它们的第一个参数，因此 Rust 允许你仅使用名称 self 在第一个参数位置缩写它。请注意，我们仍然需要在 self 简写前面使用 &，以指示此方法借用了 Self 实例，就像我们在 rectangle: &Rectangle 中所做的那样。方法可以取得 self 的所有权，不可变地借用 self（就像我们在这里所做的那样），或者可变地借用 self，就像它们可以借用任何其他参数一样。

我们在这里选择 &self 的原因与我们在函数版本中使用 &Rectangle 的原因相同：我们不想取得所有权，我们只想读取结构体中的数据，而不是写入它。如果我们想在方法执行过程中更改我们调用方法的实例，我们会将 &mut self 用作第一个参数。使用 self 作为第一个参数来获取实例所有权的方法很少见；这种技术通常用于方法将 self 转换为其他内容，并且你想防止调用者在转换后使用原始实例的情况。

除了提供方法语法并且不必在每个方法的签名中重复 self 的类型之外，使用方法而不是函数的主要原因是组织性。我们将所有可以对类型实例执行的操作放在一个 impl 块中，而不是让未来的代码用户在我们提供的库中的各个位置搜索 Rectangle 的功能。

请注意，我们可以选择为方法提供与结构体字段之一相同的名称。例如，我们可以定义一个 Rectangle 上的方法，该方法也命名为 width

文件名：src/main.rs 
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn width(&self) -> bool {
        self.width > 0
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    if rect1.width() {
        println!("The rectangle has a nonzero width; it is {}", rect1.width);
    }
}

在这里，我们选择使 width 方法在实例的 width 字段中的值大于 0 时返回 true，在值等于 0 时返回 false：我们可以在同名的方法中使用字段用于任何目的。在 main 中，当我们在 rect1.width 之后加上括号时，Rust 知道我们指的是方法 width。当我们不使用括号时，Rust 知道我们指的是字段 width。

通常，但不总是，当我们给方法提供与字段相同的名称时，我们希望它只返回字段中的值，而不做其他任何事情。这样的方法称为getter，Rust 不像其他一些语言那样自动为结构体字段实现它们。Getter 很有用，因为你可以将字段设为私有，但将方法设为公共，从而允许对该字段进行只读访问，作为类型的公共 API 的一部分。我们将在第 7 章中讨论什么是公共和私有，以及如何将字段或方法指定为公共或私有。.

-> 运算符在哪里？

在 C 和 C++ 中，使用两个不同的运算符来调用方法：如果你直接在对象上调用方法，则使用 .，如果你在指向对象的指针上调用方法，并且需要先解引用指针，则使用 ->。换句话说，如果 object 是一个指针，则 object->something() 类似于 (*object).something()。

Rust 没有等效于 -> 运算符的运算符；相反，Rust 有一个称为自动引用和解引用的功能。调用方法是 Rust 中少数具有这种行为的地方之一。

它的工作原理如下：当你使用 object.something() 调用方法时，Rust 会自动添加 &、&mut 或 *，以便 object 与方法的签名匹配。换句话说，以下是相同的

#![allow(unused)]
fn main() {
#[derive(Debug,Copy,Clone)]
struct Point {
    x: f64,
    y: f64,
}

impl Point {
   fn distance(&self, other: &Point) -> f64 {
       let x_squared = f64::powi(other.x - self.x, 2);
       let y_squared = f64::powi(other.y - self.y, 2);

       f64::sqrt(x_squared + y_squared)
   }
}
let p1 = Point { x: 0.0, y: 0.0 };
let p2 = Point { x: 5.0, y: 6.5 };
p1.distance(&p2);
(&p1).distance(&p2);
}

第一个看起来更简洁。这种自动引用行为之所以起作用，是因为方法有一个明确的接收器——self 的类型。给定方法的接收器和名称，Rust 可以明确地确定该方法是在读取 (&self)、修改 (&mut self) 还是消耗 (self)。Rust 为方法接收器隐式借用是使所有权在实践中符合人体工程学的重要组成部分。

具有更多参数的方法

让我们通过在 Rectangle 结构体上实现第二个方法来练习使用方法。这次，我们希望 Rectangle 的实例获取另一个 Rectangle 的实例，如果第二个 Rectangle 可以完全容纳在 self（第一个 Rectangle）中，则返回 true；否则，应返回 false。也就是说，一旦我们定义了 can_hold 方法，我们就希望能够编写如示例 5-14 所示的程序。

文件名：src/main.rs 
fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
    let rect2 = Rectangle {
        width: 10,
        height: 40,
    };
    let rect3 = Rectangle {
        width: 60,
        height: 45,
    };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}
示例 5-14：使用尚未编写的 can_hold 方法

预期的输出将如下所示，因为 rect2 的两个维度都小于 rect1 的维度，但 rect3 比 rect1 更宽

Can rect1 hold rect2? true
Can rect1 hold rect3? false

我们知道我们想要定义一个方法，所以它会在 impl Rectangle 块内。该方法的名称将为 can_hold，它将获取另一个 Rectangle 的不可变借用作为参数。我们可以通过查看调用方法的代码来判断参数的类型：rect1.can_hold(&rect2) 传入 &rect2，它是对 rect2（一个 Rectangle 实例）的不可变借用。这是有道理的，因为我们只需要读取 rect2（而不是写入，这意味着我们需要可变借用），并且我们希望 main 保留 rect2 的所有权，以便我们可以在调用 can_hold 方法后再次使用它。can_hold 的返回值将是一个布尔值，并且该实现将检查 self 的宽度和高度是否分别大于另一个 Rectangle 的宽度和高度。让我们将新的 can_hold 方法添加到示例 5-13 中的 impl 块中，如示例 5-15 所示。

文件名：src/main.rs 
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }

    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
    let rect2 = Rectangle {
        width: 10,
        height: 40,
    };
    let rect3 = Rectangle {
        width: 60,
        height: 45,
    };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}
示例 5-15：在 Rectangle 上实现 can_hold 方法，该方法将另一个 Rectangle 实例作为参数

当我们使用示例 5-14 中的 main 函数运行此代码时，我们将获得所需的输出。方法可以获取多个参数，这些参数是在 self 参数之后添加到签名中的，并且这些参数的工作方式与函数中的参数相同。

关联函数

在 impl 块中定义的所有函数都称为关联函数，因为它们与 impl 后面的类型相关联。我们可以定义不将 self 作为其第一个参数的关联函数（因此不是方法），因为它们不需要类型的实例即可工作。我们已经使用了一个这样的函数：在 String 类型上定义的 String::from 函数。

不是方法的关联函数通常用于构造函数，这些构造函数将返回该结构体的新实例。这些通常称为 new，但 new 不是一个特殊的名称，也不是内置于该语言中的。例如，我们可以选择提供一个名为 square 的关联函数，该函数将具有一个维度参数，并将其用作宽度和高度，从而可以更轻松地创建正方形 Rectangle，而不必指定两次相同的值

文件名：src/main.rs

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn square(size: u32) -> Self {
        Self {
            width: size,
            height: size,
        }
    }
}

fn main() {
    let sq = Rectangle::square(3);
}

返回类型和函数主体中的 Self 关键字是 impl 关键字后出现的类型的别名，在本例中为 Rectangle。

要调用此关联函数，我们使用带有结构体名称的 :: 语法；let sq = Rectangle::square(3); 是一个示例。此函数由结构体命名空间：:: 语法用于关联函数和模块创建的命名空间。我们将在第 7 章中讨论模块。.

多个 impl 块

允许每个结构体有多个 impl 块。例如，示例 5-15 等效于示例 5-16 中显示的代码，其中每个方法都有自己的 impl 块。

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
    let rect2 = Rectangle {
        width: 10,
        height: 40,
    };
    let rect3 = Rectangle {
        width: 60,
        height: 45,
    };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}
示例 5-16：使用多个 impl 块重写示例 5-15

这里没有理由将这些方法分隔到多个 impl 块中，但这是一种有效的语法。我们将在第 10 章中看到多个 impl 块有用的情况，我们在其中讨论泛型类型和 trait。

总结

结构体允许你创建对你的领域有意义的自定义类型。通过使用结构体，你可以将相关的数据片段彼此连接起来，并为每个片段命名，使你的代码清晰明了。在 impl 代码块中，你可以定义与你的类型关联的函数，而方法是一种关联函数，它允许你指定结构体实例的行为。

但结构体并不是创建自定义类型的唯一方法：让我们转向 Rust 的枚举特性，为你的工具箱添加另一个工具。