Rust 結構體

Rust 中的結構體(Struct)與元組(Tuple)都可以將若干個類型不一定相同的數據捆綁在一起形成整體,但結構體的每個成員和其本身都有一個名字,這樣訪問它成員的時候就不用記住下標了。元組常用于非定義的多值傳遞,而結構體用于規范常用的數據結構。結構體的每個成員叫做"字段"。

結構體定義

這是一個結構體定義:

struct Site {
    domain: String,
    name: String,
    nation: String,
    found: u32
}

注意:如果你常用 C/C++,請記住在 Rust 里 struct 語句進用來定義,不能聲明實例,結尾不需要 ; 符號,而且每個字段定義之后用 , 分隔。

結構體實例

Rust 很多地方受 JavaScript 影響,在實例化結構體的時候用 JSON 對象的 key: value 語法來實現定義:

實例

let?runoob?=?Site?{
????domain:?String::from("www.jrdxt.com"),
????name:?String::from("RUNOOB"),
????nation:?String::from("China"),
????found:?2013
};

如果你不了解 JSON 對象,你可以不用管它,記住格式就可以了:

結構體類名 {
    字段名 : 字段值,
    ...
}

這樣的好處是不僅使程序更加直觀,還不需要按照定義的順序來輸入成員的值。

如果正在實例化的結構體有字段名稱和現存變量名稱一樣的,可以簡化書寫:

實例


let?domain?=?String::from("www.jrdxt.com");
let?name?=?String::from("RUNOOB");
let?runoob?=?Site?{
????domain,  // 等同于 domain : domain,
????name,    // 等同于 name : name,
????nation:?String::from("China"),
????traffic:?2013
};

有這樣一種情況:你想要新建一個結構體的實例,其中大部分屬性需要被設置成與現存的一個結構體屬性一樣,僅需更改其中的一兩個字段的值,可以使用結構體更新語法:

let site = Site {
    domain: String::from("www.example.com"),
    name: String::from("EXAMPLE"),
    ..runoob
};

注意:..runoob 后面不可以有逗號。這種語法不允許一成不變的復制另一個結構體實例,意思就是說至少重新設定一個字段的值才能引用其他實例的值。

元組結構體

有一種更簡單的定義和使用結構體的方式:元組結構體

元組結構體是一種形式是元組的結構體。

與元組的區別是它有名字和固定的類型格式。它存在的意義是為了處理那些需要定義類型(經常使用)又不想太復雜的簡單數據:

struct Color(u8, u8, u8);
struct Point(f64, f64);

let black = Color(0, 0, 0);
let origin = Point(0.0, 0.0);

"顏色"和"點坐標"是常用的兩種數據類型,但如果實例化時寫個大括號再寫上兩個名字就為了可讀性犧牲了便捷性,Rust 不會遺留這個問題。元組結構體對象的使用方式和元組一樣,通過 . 和下標來進行訪問:

實例

fn main() {
    struct Color(u8, u8, u8);
    struct Point(f64, f64);

    let black = Color(0, 0, 0);
    let origin = Point(0.0, 0.0);

    println!("black = ({}, {}, {})", black.0, black.1, black.2);
    println!("origin = ({}, {})", origin.0, origin.1);
}

運行結果:

black = (0, 0, 0)
origin = (0, 0)

結構體所有權

結構體必須掌握字段值所有權,因為結構體失效的時候會釋放所有字段。

這就是為什么本章的案例中使用了 String 類型而不使用 &str 的原因。

但這不意味著結構體中不定義引用型字段,這需要通過"生命周期"機制來實現。

但現在還難以說明"生命周期"概念,所以只能在后面章節說明。

輸出結構體

調試中,完整地顯示出一個結構體實例是非常有用的。但如果我們手動的書寫一個格式會非常的不方便。所以 Rust 提供了一個方便地輸出一整個結構體的方法:

實例

#[derive(Debug)]

struct Rectangle {
    width: u32,
    height: u32,
}

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

    println!("rect1 is {:?}", rect1);
}

如第一行所示:一定要導入調試庫 #[derive(Debug)] ,之后在 println 和 print 宏中就可以用 {:?} 占位符輸出一整個結構體:

rect1 is Rectangle { width: 30, height: 50 }

如果屬性較多的話可以使用另一個占位符 {:#?}

輸出結果:

rect1 is Rectangle {
    width: 30,
    height: 50
}

結構體方法

方法(Method)和函數(Function)類似,只不過它是用來操作結構體實例的。

如果你學習過一些面向對象的語言,那你一定很清楚函數一般放在類定義里并在函數中用 this 表示所操作的實例。

Rust 語言不是面向對象的,從它所有權機制的創新可以看出這一點。但是面向對象的珍貴思想可以在 Rust 實現。

結構體方法的第一個參數必須是 &self,不需聲明類型,因為 self 不是一種風格而是關鍵字。

計算一個矩形的面積:

實例

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!("rect1's area is {}", rect1.area());
}

輸出結果:

rect1's area is 1500

請注意,在調用結構體方法的時候不需要填寫 self ,這是出于對使用方便性的考慮。

一個多參數的例子:

實例

struct?Rectangle?{
????width:?u32,
????height:?u32,
}

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

????fn?wider(&self,?rect:?&Rectangle)?->?bool?{
????????self.width?>?rect.width
????}
}

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

????println!("{}",?rect1.wider(&rect2));
}

運行結果:

false

這個程序計算 rect1 是否比 rect2 更寬。


結構體關聯函數

之所以"結構體方法"不叫"結構體函數"是因為"函數"這個名字留給了這種函數:它在 impl 塊中卻沒有 &self 參數。

這種函數不依賴實例,但是使用它需要聲明是在哪個 impl 塊中的。

一直使用的 String::from 函數就是一個"關聯函數"。

實例

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

impl Rectangle {
    fn create(width: u32, height: u32) -> Rectangle {
        Rectangle { width, height }
    }
}

fn main() {
    let rect = Rectangle::create(30, 50);
    println!("{:?}", rect);
}

運行結果:

Rectangle { width: 30, height: 50 }

貼士:結構體 impl 塊可以寫幾次,效果相當于它們內容的拼接!

單元結構體

結構體可以值作為一種象征而無需任何成員:

struct UnitStruct;

我們稱這種沒有身體的結構體為單元結構體(Unit Struct)。