1. 方法（Methods）是什么？

在 Rust 里，方法和函數(shù)的定義方式很像：

• 都使用 fn 來聲明。
• 都能擁有參數(shù)和返回值。
• 都包含一段在被調(diào)用時執(zhí)行的代碼邏輯。

不同點在于： 方法必須定義在某個具體類型（比如 struct、enum 或者在某個 trait 對象里）的上下文中。而且方法的第一個參數(shù)固定要寫成 self（可以是 self、&self 或者 &mut self），用來代表調(diào)用該方法的具體實例。

讓我們來看看一個簡單示例。假設我們有一個 Rectangle 結(jié)構體：

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

如果你想為 Rectangle 實例添加一個計算面積的功能，我們可以在 impl（implementation）塊中為它定義一個方法 area：

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

• 這里 impl Rectangle { ... } 表示這個塊里的所有函數(shù)都與 Rectangle 類型相關聯(lián)。
• fn area(&self) -> u32 說明：這是一個方法，第一個參數(shù)是 &self，表示以不可變引用的形式訪問當前調(diào)用該方法的 Rectangle 實例。
• self.width 和 self.height 即代表該實例的字段。用 self 訪問字段非常直觀。

在 main 函數(shù)中，當我們創(chuàng)建一個矩形實例后，就可以使用方法語法來獲取面積：

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
    
    println!("rect1 的面積是：{}", rect1.area());
}

運行后，會輸出：

rect1 的面積是：1500

2. 為什么要使用 &self 而不是 &Rectangle？

在我們將 area 從一個普通函數(shù)重構為一個方法時，你會注意到，函數(shù)簽名由原本的

fn area(rectangle: &Rectangle) -> u32 { ... }

變?yōu)?/p>

fn area(&self) -> u32 { ... }

這是因為在 impl Rectangle 這個上下文中，Rust 給出了一個更具可讀性的方式：讓第一個參數(shù)自動變?yōu)?self，而 Self 則是當前實現(xiàn)塊對應的類型別名。

如果你需要修改實例的字段，你可以將第一個參數(shù)寫為 &mut self；如果需要獲取所有權并可能在方法內(nèi)部把它“轉(zhuǎn)化”成別的東西，則用 self。但這種把所有權轉(zhuǎn)移給方法本身的做法很少見。

在大多數(shù)情況下，我們只是想讀一下結(jié)構體數(shù)據(jù)而不改變它，這時使用 &self 最為常見，也能讓調(diào)用者繼續(xù)使用這個實例。

3. 同名字段與同名方法

如果你在 Rectangle 內(nèi)也有一個字段叫做 width，同時還想定義一個方法也叫 width，這是合法的。比如：

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

在調(diào)用時：

• rect.width （不帶括號）訪問的是字段 width 的數(shù)值。
• rect.width() （帶括號）調(diào)用的是同名方法，返回一個布爾值。

在很多語言中，如果你只想單純地返回字段值，會把這種方法稱為“getter”。

Rust 并不會為你自動生成 getter，但你可以自行定義。

這樣一來，你可以只把字段設為私有，但對外公開這個只讀方法，讓外部安全地訪問它。

4. 借用與解引用：為什么在調(diào)用方法時不需要寫 & 或 *？

在 C/C++ 中，如果你要通過指針來調(diào)用成員函數(shù)，需要寫 ->。或者，如果你手頭是指針，還要顯式地 (*object).method() 等。

在 Rust 中則不需要這么麻煩，因為自動引用和解引用讓你可以直接寫 object.method()。

實際上，這些調(diào)用是一樣的：

p1.distance(&p2);
(&p1).distance(&p2);

Rust 會根據(jù)方法簽名（第一個參數(shù)是 &self、&mut self 還是 self）來自動推斷是否需要幫你加 &、&mut 或者 *。這大大簡化了調(diào)用方法時的語法。

5. 方法可以擁有多個參數(shù)

方法和函數(shù)在參數(shù)上并沒什么區(qū)別，除了第一個參數(shù)是 self 以外，其他參數(shù)你可以自由添加。

舉例來說，為 Rectangle 再定義一個方法 can_hold，用來檢查“當前矩形”是否可以完全容納另一個矩形：

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)); // true
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3)); // false
}

6. 關聯(lián)函數(shù)（Associated Functions）

如果在 impl 塊中定義的函數(shù)沒有 self 參數(shù)，那它就不是方法（method），而是關聯(lián)函數(shù)（associated function）。

關聯(lián)函數(shù)常被用來提供類似“構造函數(shù)”的功能。

舉個例子，如果你想快速構造一個“正方形”：

impl Rectangle {
    // 關聯(lián)函數(shù)
    fn square(size: u32) -> Self {
        Self {
            width: size,
            height: size,
        }
    }
}

調(diào)用的時候，使用 :: 語法來調(diào)用關聯(lián)函數(shù)：

fn main() {
    let sq = Rectangle::square(3);
    println!("正方形 sq: {:#?}", sq);
}

打印結(jié)果為：

正方形 sq: Rectangle {
    width: 3,
    height: 3
}

在標準庫里，我們也經(jīng)?？吹竭@種關聯(lián)函數(shù)，比如 String::from("Hello")。它不需要某個已存在的 String 實例，就可以直接調(diào)用，用來創(chuàng)建一個新的字符串。

7. 多個 impl 塊

你可以為同一個類型寫多個 impl 塊，比如：

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
    }
}

這與把它們寫在同一個 impl 中沒有本質(zhì)差別。之所以 Rust 允許你分開寫，是為了在某些情況下（比如涉及到泛型、trait 實現(xiàn)等）組織代碼更靈活。

8. 總結(jié)

• 方法：必須定義在某個類型（如 struct）的 impl 塊中，第一個參數(shù)是 self（可變或不可變）。方法往往用于描述該類型實例的某些行為，讀或?qū)懫鋬?nèi)部數(shù)據(jù)。
• 關聯(lián)函數(shù)：在 impl 塊里定義但不包含 self 參數(shù)的函數(shù)。常用于構造新實例或提供一些與實例無關的功能。
• Rust 擁有自動引用和解引用特性，讓我們可以簡潔地使用 object.method() 來調(diào)用方法。
• 多個 impl 塊可以并存，給代碼的組織提供了很大靈活性。

通過為自定義類型定義方法，我們不僅能讓代碼更具可讀性，把相關的行為放到同一個 impl 塊中，也能充分利用所有權、借用等特性來保證內(nèi)存安全和并發(fā)安全。

希望這篇文章能幫你搞清楚在 Rust 中如何編寫方法、何時使用 &self、&mut self、self，以及如何借助關聯(lián)函數(shù)讓代碼更簡潔優(yōu)雅。

如果你還對 Rust 中的枚舉（enum）或 trait 有興趣，不妨繼續(xù)閱讀之后的章節(jié)，它們和 struct 一樣，也是構建復雜邏輯的重要工具。

當然，以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。

最新評論