Rust數(shù)據(jù)類型之結(jié)構(gòu)體Struct的使用

更新時間：2023年12月07日 10:03:53 作者：Hann?Yang

結(jié)構(gòu)體是Rust中非常強大和靈活的數(shù)據(jù)結(jié)構(gòu),可以用于組織和操作各種類型的數(shù)據(jù),本文就來介紹一下Rust數(shù)據(jù)類型之結(jié)構(gòu)體Struct的使用,感興趣的可以了解一下

結(jié)構(gòu)體（Struct）

是一種自定義數(shù)據(jù)類型，允許將多個相關(guān)的值組合在一起，形成一個更復(fù)雜的數(shù)據(jù)結(jié)構(gòu)。結(jié)構(gòu)體被廣泛應(yīng)用于組織和管理數(shù)據(jù)，具有靈活性和強大的表達能力。

定義與聲明

結(jié)構(gòu)體定義

在Rust中，定義和聲明結(jié)構(gòu)體的語法如下：

struct Name {  
    field1: Type1,  
    field2: Type2,  
    // ...  
    fieldN: TypeN,  
}

其中，Name是結(jié)構(gòu)體的名稱，每個數(shù)據(jù)名及其對應(yīng)的數(shù)據(jù)類型組成一個字段，field1到fieldN是結(jié)構(gòu)體的字段名稱，Type1到TypeN是字段的數(shù)據(jù)類型。

通過關(guān)鍵字 struct 定義，指定結(jié)構(gòu)體名稱，結(jié)構(gòu)體內(nèi)用 field:type, 表示字段名稱及數(shù)據(jù)類型，注意rust語言不能在定義的同時進行賦值，且用逗號分隔各字段，不像c/c++用分號。

結(jié)構(gòu)體中可以根據(jù)需要定義字段個數(shù)，理論上要多少就定義多少；但實際上字段太多，結(jié)構(gòu)體也會變得很占空間，對程序的空間效率是個負擔(dān)。

結(jié)構(gòu)體實例

如以下代碼定義了一個名為Point的結(jié)構(gòu)體，包含x和y兩個字段，類型分別為i32和f64：

struct Point {
    x: i32,
    y: f64,
}

定義結(jié)構(gòu)體后，可以像使用其他類型一樣使用它。例如，可以聲明一個Point類型的變量，并為其字段賦值：

let my_point = Point { x: 10, y: 20.0 };

使用結(jié)構(gòu)體時，用成員運算符 my_point.x 來調(diào)用對應(yīng)字段的值：

println!("({},{})", point.x, point.y);    // 輸出：(10,20)

可變實例

需要變動字段的值，在聲明時需要用 let mut，如：

struct Point {  
    x: i32,  
    y: f64,  
}

fn main() {
	let mut point = Point { x: 10, y: 20.0 }; 
	point.x = 5;
    println!("({},{})", point.x, point.y);  // 輸出：(5,20)
}

結(jié)構(gòu)體分類

在Rust中，結(jié)構(gòu)體（Struct）可以按照不同的方式進行分類，以下是一些常見的分類方式：

單元結(jié)構(gòu)體（Unit Struct）

這種結(jié)構(gòu)體沒有任何字段，它只是用于表示一個空的類型。這種結(jié)構(gòu)體通常用于作為其他結(jié)構(gòu)體的組成部分或返回類型。例如：

struct UnitStruct;

元組結(jié)構(gòu)體（Tuple Struct）

這種結(jié)構(gòu)體包含一組字段，可以通過元組語法來訪問每個字段。元組結(jié)構(gòu)體可以用于表示簡單的數(shù)據(jù)集合，不使用大括號{}，而是使用元組的小括號()。例如：

struct TupleStruct(i32, String);

相當(dāng)字段數(shù)據(jù)沒有名稱的結(jié)構(gòu)體，訪問時使用索引。如：

struct Point (i32, f64);

fn main() {
	let mut point = Point(10, 20.0); 
	point.0 = 5;
    println!("({},{})", point.0, point.1);  
}

具名結(jié)構(gòu)體（Named Struct）

這種結(jié)構(gòu)體有一個顯式的名稱，并且包含一組字段。具名結(jié)構(gòu)體可以用于表示復(fù)雜的數(shù)據(jù)結(jié)構(gòu)，例如一個包含多個字段的對象，本文的示例大多數(shù)都為具名結(jié)構(gòu)體，用法已在本文開頭講過：

struct MyStruct {  
    field1: i32,  
    field2: String,  
    // ...  
}

除了以上三種常見的結(jié)構(gòu)體類型，Rust還支持其他特殊類型的結(jié)構(gòu)體，例如帶有泛型參數(shù)的結(jié)構(gòu)體、具名元組結(jié)構(gòu)體（Named Tuple Struct）和結(jié)構(gòu)體路徑（Struct Type Alias）等。

需要注意的是，在Rust中，結(jié)構(gòu)體的分類并不是強制性的，也就是說，一個結(jié)構(gòu)體可以包含任意類型的字段，并且可以在任何地方使用。這使得結(jié)構(gòu)體非常靈活，可以用于實現(xiàn)各種復(fù)雜的數(shù)據(jù)結(jié)構(gòu)。

結(jié)構(gòu)體字段的數(shù)據(jù)類型可以是以下常見的rust數(shù)據(jù)，甚至可以是函數(shù)、引用、指針類型。

標量類型（Scalar Types）：
- 整數(shù)類型（Integer Types）：包括有符號整數(shù)類型和無符號整數(shù)類型。常見的整數(shù)類型有 i8、i16、i32、i64、i128 表示有符號整數(shù)，u8、u16、u32、u64、u128 表示無符號整數(shù)。此外，還有 isize 和 usize，它們根據(jù)平臺的位數(shù)自動調(diào)整大小。
- 浮點數(shù)類型（Floating-Point Number Types）：包括 f32 和 f64 兩種類型，表示單精度和雙精度浮點數(shù)。
- 布爾類型（Boolean Type）：只有兩個取值，true 和 false。
- 字符類型（Character Type）：表示單個 Unicode 字符，通常存儲為 4 個字節(jié)。
復(fù)合類型（Composite Types）：
- 數(shù)組類型（Array Types）：由相同類型的元素組成的有限集合。可以通過固定長度或動態(tài)長度來定義數(shù)組。
- 切片類型（Slice Types）：對一個連續(xù)的內(nèi)存塊進行引用，可以看作是動態(tài)數(shù)組。切片類型提供了訪問和操作數(shù)據(jù)的一種高效方式。
- 元組類型（Tuple Types）：一種將多個不同類型的值組合在一起的數(shù)據(jù)結(jié)構(gòu)，用圓括號和逗號分隔的元素序列表示。元組可以包含不同類型的元素，例如整數(shù)、浮點數(shù)、布爾值、字符串等。
- 結(jié)構(gòu)體類型（Struct Types）：一種自定義的數(shù)據(jù)類型，可以包含多個不同類型的字段。結(jié)構(gòu)體可以通過定義來指定其字段和屬性。
- 枚舉類型（Enum Types）：表示一個可能取多個值的變量。在 Rust 中，枚舉類型使用 enum 關(guān)鍵字定義，每個可能的取值都是一個不同的枚舉成員。

結(jié)構(gòu)體嵌套

一個結(jié)構(gòu)體可以包含任意類型的字段，當(dāng)然也包括結(jié)構(gòu)體。

在以下這個例子中，Address 結(jié)構(gòu)體包含了 street、city 和 state 三個字段，而 Person 結(jié)構(gòu)體則包含了 name、age 和 address 三個字段，其中 address 字段的類型是 Address 結(jié)構(gòu)體。

struct Address {  
    street: String,  
    city: String,  
    state: String,  
}  
  
struct Person {  
    name: String,  
    age: u8,  
    address: Address,  
}

結(jié)構(gòu)體方法

方法（method）是在結(jié)構(gòu)體上定義的功能，可以訪問結(jié)構(gòu)體的字段并執(zhí)行一些操作。使用關(guān)鍵字impl，結(jié)構(gòu)體可以對應(yīng)一個或多個impl代碼塊。

例1：結(jié)構(gòu)體轉(zhuǎn)換為字符串描述

struct Student {
    name:String,
    age:u32,
    school:String,
    major:String,
    grade:String,
    state:bool
}
  
impl Student {  
    fn to_string(&self) -> String {  
        format!("Student {{ name: {}, age: {}, school: {}, major: {}, grade: {}, state: {} }}", 
            self.name, self.age, self.school, self.major, self.grade, self.state)  
    }  
} 

fn main() {
    let school = String::from("東南大學(xué)");
    let major = String::from("土木工程學(xué)院");
    let s = Student{
        name:String::from("楊程"),
        age:22,
        school,
        major,
        grade:String::from("大三"),
        state:true
    };
    println!("{}", s.to_string());
}

輸出：

Student { name: 楊程, age: 22, school: 東南大學(xué), major: 土木工程學(xué)院, grade: 大三, state: true }

注意：上例中有一個rust結(jié)構(gòu)體的特殊用法，使用同名變量在結(jié)構(gòu)體外為對應(yīng)字段賦值。

例2：矩形的周長和面積

struct Rectangle {  
    width: f32,  
    height: f32,  
}  
  
impl Rectangle {  
    // 構(gòu)造函數(shù)  
    fn new(width: f32, height: f32) -> Rectangle {  
        Rectangle { width, height }  
    }  
  
    // 計算矩形的面積  
    fn area(&self) -> f32 {  
        self.width * self.height  
    }  
  
    // 計算矩形的周長  
    fn perimeter(&self) -> f32 {  
        (self.width + self.height) * 2.0
    }  
}

impl Rectangle {  
    // 判斷矩形是否相等  
    fn is_equal(&self, other: &Rectangle) -> bool {  
        self.width == other.width && self.height == other.height  
    }  
}  
  
fn main() {  
    let rect1 = Rectangle::new(5.0, 6.0);  
    let rect2 = Rectangle::new(5.0, 6.0);  
  
    println!("Rectangle 1 area: {}", rect1.area());  
    println!("Rectangle 1 perimeter: {}", rect1.perimeter());  
  
    println!("Rectangle 2 area: {}", rect2.area());  
    println!("Rectangle 2 perimeter: {}", rect2.perimeter());  
  
    if rect1.is_equal(&rect2) {  
        println!("Rectangles are equal");  
    } else {  
        println!("Rectangles are not equal");  
    }  
}

輸出：

Rectangle 1 area: 30
Rectangle 1 perimeter: 22
Rectangle 2 area: 30
Rectangle 2 perimeter: 22
Rectangles are equal

例3：結(jié)構(gòu)體字段的更新與輸出

struct Person {  
    name: String,  
    age: u32,  
}  
  
impl Person {  
    // 這是構(gòu)造函數(shù)，用于創(chuàng)建一個新的 Person 實例  
    fn new(name: String, age: u32) -> Person {  
        Person { name, age }  
    }  
  
    fn say_hello(&self) {  
        println!("Hello, my name is {} and I'm {}.", self.name, self.age);  
    }  
  
    fn update_age(&mut self, new_age: u32) {  
        self.age = new_age;  
    } 

    fn update_name(&mut self, new_name: String) {  
        self.name = new_name;  
    }  
}  
  
fn main() {  
    // 創(chuàng)建一個新的 Person 實例  
    let mut person = Person::new("Tom".to_string(), 5);  
  
    // 調(diào)用 say_hello 方法，輸出 Person 的信息  
    person.say_hello();  
  
    // 調(diào)用 update_age 方法，更新 Person 的年齡  
    person.update_age(3);  
  
    // 再次調(diào)用 say_hello 方法，輸出更新后的信息  
    person.say_hello(); 

    person.update_age(5);
    person.update_name(String::from("Jerry"));  
    person.say_hello();  
}

輸出：

Hello, my name is Tom and I'm 5.
Hello, my name is Tom and I'm 3.
Hello, my name is Jerry and I'm 5.

關(guān)聯(lián)函數(shù)

之所以"結(jié)構(gòu)體方法"不叫"結(jié)構(gòu)體函數(shù)"是因為"函數(shù)"這個名字留給了這種函數(shù)：它在 impl 塊中卻沒有 &self 參數(shù)。這種函數(shù)不依賴實例，但是使用它需要聲明是在哪個 impl 塊中的，比如上小節(jié)例2和例3中的構(gòu)造函數(shù)new()就是關(guān)聯(lián)函數(shù)，類似于字符串函數(shù)String::new()，String::from("Jerry")。

示例：

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

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

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

輸出：

Rectangle { width: 30, height: 50 }
Area: 1500
Area: 1500

結(jié)構(gòu)體方法與關(guān)聯(lián)函數(shù)的區(qū)別

參數(shù)傳遞方式的區(qū)別

結(jié)構(gòu)體方法：結(jié)構(gòu)體方法默認情況下是可變的（mutable），也就是說可以修改結(jié)構(gòu)體的字段。在調(diào)用方法時，可以通過引用（&self）或可變引用（&mut self）來傳遞結(jié)構(gòu)體實例，以便修改其字段。例如：my_struct.my_method(&mut my_struct)。

關(guān)聯(lián)函數(shù)：關(guān)聯(lián)函數(shù)默認情況下是不可變的（immutable），也就是說無法修改結(jié)構(gòu)體的字段。在調(diào)用函數(shù)時，只能通過常量引用（&self）來傳遞結(jié)構(gòu)體實例，因為常量引用是只讀的。例如：let my_struct = MyStruct {...}; my_struct.my_function()。

使用方式的區(qū)別

結(jié)構(gòu)體方法：結(jié)構(gòu)體方法可以直接在結(jié)構(gòu)體實例上調(diào)用，無需顯式傳遞結(jié)構(gòu)體實例。例如：my_struct.my_method()。

關(guān)聯(lián)函數(shù)：關(guān)聯(lián)函數(shù)需要顯式傳遞結(jié)構(gòu)體實例作為參數(shù)。例如：MyStruct::my_function(my_struct)。

結(jié)構(gòu)體的trait

Rust 中的 trait 是一種抽象類型，用于定義泛型行為，trait 可以理解為一種接口。trait 使用關(guān)鍵字 derive 來自動生成實現(xiàn)。通過使用 derive，可以避免手動編寫冗長的代碼，提高代碼的可讀性和可維護性。trait 有很多，比如Copy，Clone，Debug，Default，Drop，Hash，Ord，PartialOrd，Send，Sync等等，先挑幾種最常用的學(xué)一下：

#[derive(Debug)]

在 Rust 語言中用于自動生成一個結(jié)構(gòu)體的 Debug 實現(xiàn)，Debug 是 Rust 標準庫中的一個 trait，用于在控制臺打印調(diào)試信息。

使用 #[derive(Debug)] 屬性可以為結(jié)構(gòu)體自動生成一個 Debug 實現(xiàn)，這樣在需要打印調(diào)試信息時，就可以使用 {:?} 格式化字符串來打印該結(jié)構(gòu)體的內(nèi)容。例如，在上面的代碼中，s 結(jié)構(gòu)體的 Debug 實現(xiàn)已經(jīng)被自動生成，因此可以使用 println!("{:?}", s) 來打印出結(jié)構(gòu)體 s 的內(nèi)容。

例1：

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn distance(&self, other: &Point) -> f32 {
        let x_diff = self.x - other.x;
        let y_diff = self.y - other.y;
        ((x_diff * x_diff + y_diff * y_diff) as f32).sqrt()
    }
}

fn main() {
    let p1 = Point { x: 3, y: 0 };
    let p2 = Point { x: 0, y: 4 };
    println!("Distance between {:?} and {:?} is {}.", p1, p2, p1.distance(&p2));
}

輸出：

Distance between Point { x: 3, y: 0 } and Point { x: 0, y: 4 } is 5.

例2：

#[derive(Debug)]
struct Student {
    name: String,
    age: u32,
    school: String,
    major: String,
    grade: String,
    state: bool,
}  

impl Student {
    fn new() -> Student {
        return Student {
            age: 0,
            name: String::new(),
            school: String::from(""),
            major: "".to_string(),
            grade: "".to_string(),
            state: false,
        };
    }
}

fn main() {  
    let mut s = Student::new();
    s.name = String::from("楊程");
    s.age = 22;
    s.school = String::from("東南大學(xué)");
    s.major = String::from("土木工程學(xué)院");
    s.grade = String::from("大三");
    s.state = true;
    println!("{:?}", s);
}

輸出：

Student { name: "楊程", age: 22, school: "東南大學(xué)", major: "土木工程學(xué)院", grade: "大三", state: true }

與上一小節(jié)的例2對比，輸出內(nèi)容基本一致，就多了String的引號標記。相比自動生成 Debug 實現(xiàn)可以簡化代碼編寫過程，并且可以避免手動實現(xiàn) Debug 時可能出現(xiàn)的錯誤。

在本例中，使用宏打印結(jié)構(gòu)體println!("{:?}", s);時，第一行的代碼#[derive(Debug)]是必須的，如果去掉就會報錯：

error[E0277]: `Student` doesn't implement `Debug`
--> E:\.rs\struct2.rs:31:22
|
31 | println!("{:?}", s);
| ^ `Student` cannot be formatted using `{:?}`
|
= help: the trait `Debug` is not implemented for `Student`
= note: add `#[derive(Debug)]` to `Student` or manually `impl Debug for Student`
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider annotating `Student` with `#[derive(Debug)]`
|
1 + #[derive(Debug)]
2 | struct Student {
|

error: aborting due to previous error

自定義打印宏

1. impl fmt::Debug for Student

返回值：fmt::Result；調(diào)用：println!("{:?}", s);

use std::fmt;

struct Student {
    name: String,
    age: u32,
    school: String,
    major: String,
    grade: String,
    state: bool,
}  
  
impl fmt::Debug for Student {  
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f,
               "Student {{ name: {}, age: {}, school: {}, major: {}, grade: {}, state: {} }}",
               self.name, self.age, self.school, self.major, self.grade, self.state)
    }  
}  
  
fn main() {  
    let school = String::from("東南大學(xué)");
    let major = String::from("土木工程學(xué)院");
    let s = Student {
        name: String::from("楊程"),
        age: 22,
        school,
        major,
        grade: String::from("大三"),
        state: true,
    };  
    println!("{:?}", s);
}

輸出：

Student { name: 楊程, age: 22, school: 東南大學(xué), major: 土木工程學(xué)院, grade: 大三, state: true }

2. impl fmt::Display for Student

返回值：fmt::Result；調(diào)用：println!("{}", s); {}里不需要:?

use std::fmt;

struct Point {
    x: i32,
    y: i32,
}

impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

impl Point {
    fn distance(&self, other: &Point) -> f32 {
        let x_diff = self.x - other.x;
        let y_diff = self.y - other.y;
        ((x_diff * x_diff + y_diff * y_diff) as f32).sqrt()
    }
}

fn main() {
    let p1 = Point { x: 3, y: 0 };
    let p2 = Point { x: 0, y: 4 };
    println!("Distance between {} and {} is {}.", p1, p2, p1.distance(&p2));
}

輸出：

Distance between Point(3, 0) and Point(0, 4) is 5.

輸出要與使用#[derive(Debug)]時一樣，只要修改write宏的第2個參數(shù)，如：

impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Point {{ x: {}, y: {} }}", self.x, self.y)
    }
}

#[derive(PartialEq)]

使用#[derive(PartialEq)]為結(jié)構(gòu)體自動實現(xiàn)了PartialEq trait。這使得可以直接使用==運算符比較兩個結(jié)構(gòu)體實例的相等性。

例1：

#[derive(PartialEq)]
struct Point {  
    x: i32,  
    y: i32,  
}

fn main() {
	let point1 = Point { x: 10, y: 20 };  
	let point2 = Point { x: 10, y: 20 };  
	if point1 == point2 {  
	    println!("The two points are equal.");  
	} else {  
	    println!("The two points are not equal.");  
	}
}

輸出：

The two points are equal.

例2：

#[derive(Debug, PartialEq)]
struct Person {
    name: String,
    age: u32,
}

fn main() {
    let person1 = Person {
        name: String::from("Alice"),
        age: 25,
    };

    let person2 = Person {
        name: String::from("Bob"),
        age: 30,
    };

    let person3 = Person {
        name: String::from("Alice"),
        age: 25,
    };

    println!("Is {:?} equal to {:?}? {}", person1, person2, person1 == person2);
    println!("Is {:?} equal to {:?}? {}", person1, person3, person1 == person3);
}

輸出：

Is Person { name: "Alice", age: 25 } equal to Person { name: "Bob", age: 30 }? false
Is Person { name: "Alice", age: 25 } equal to Person { name: "Alice", age: 25 }? true

#[derive(Default)]

調(diào)用#[derive(Default)]，相當(dāng)于創(chuàng)建一個默認的結(jié)構(gòu)體實例，每一個字段都是對應(yīng)數(shù)據(jù)類型的默認值，無需手動為每個字段設(shè)置默認值。

例1：

#[derive(Default,Debug)]
struct Circle {
    radius: f32,
}  

impl Circle {
    fn area(&self) -> f32 {
        let pi = std::f32::consts::PI;
        pi * self.radius * self.radius
    }
}

fn main() {
    let mut c = Circle::default();
    println!("Circular area of {:?} = {}.", c, c.area());
    c.radius = 1.0;
    println!("Circular area of {:?} = {}.", c, c.area());
}

輸出：

Circular area of Circle { radius: 0.0 } = 0.
Circular area of Circle { radius: 1.0 } = 3.1415927.

例2：

#[derive(Debug, Default)]
struct Student {  
    name: String,  
    age: u32,  
    school: String,  
    major: String,  
    grade: String,  
    state: bool,  
}  
  
fn main() {  
    let mut s1 = Student::default(); 
    println!("{:?}", s1);
    
    s1.name = String::from("楊程");  
    s1.age = 22;  
    s1.school = String::from("東南大學(xué)");  
    s1.major = String::from("土木工程學(xué)院");  
    s1.grade = String::from("大三");  
    s1.state = true;  
    println!("{:?}", s1);  
  
    let s2 = Student {  
        age: 23,  
        grade: String::from("大四"),  
        ..s1  //注意這里的結(jié)構(gòu)體更新語法
    };  
    println!("{:?}", s2);  
}

輸出：

Student { name: "", age: 0, school: "", major: "", grade: "", state: false }
Student { name: "楊程", age: 22, school: "東南大學(xué)", major: "土木工程學(xué)院", grade: "大三", state: true }
Student { name: "楊程", age: 23, school: "東南大學(xué)", major: "土木工程學(xué)院", grade: "大四", state: true }

此例還有一個rust結(jié)構(gòu)體的特殊用法，當(dāng)結(jié)構(gòu)體大部分字段需要被設(shè)置成與現(xiàn)存的另一個結(jié)構(gòu)體的一樣，僅需更改其中的一兩個字段的值，可以使用結(jié)構(gòu)體更新語法，在現(xiàn)存的結(jié)構(gòu)體名前加上兩個連續(xù)的句號：“..Struct_Name”。

#[derive(Clone)]

Clone 在復(fù)制過程中對所有字段進行逐個復(fù)制，包括所有引用類型和原始類型。這意味著每次進行克隆時，都會創(chuàng)建新的數(shù)據(jù)副本。

示例：

#[derive(Clone)]
struct Person {  
    name: String,  
    age: i32,  
}  
  
fn main() {  
    let mut person1 = Person { name: String::new(), age: 0 };  
    let mut person2 = person1.clone();

    person1.name = "Alice".to_string();
    person1.age = 22;
    println!("Person 1: {}, {}", person1.name, person1.age);
    println!("Person 2: {}, {}", person2.name, person2.age);
    person2 = person1.clone();
    println!("Person 2: {}, {}", person2.name, person2.age);
}

輸出：

Person 1: Alice, 22
Person 2: , 0
Person 2: Alice, 22

其他相關(guān)內(nèi)容

模式匹配

結(jié)構(gòu)體可用模式匹配（Pattern Matching）來解構(gòu)和訪問其字段。

例1：

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 10, y: 20 };

    match p {
        Point { x, y } => {
            println!("x:{}, y: {}", x, y);
        }
    }
}

例2：

struct Time {  
    hour: i32,  
    minute: i32,  
    second: i32,  
}  
  
fn main() {  
    let t = Time { hour: 10, minute: 30, second: 45 };  
    match t {  
        Time { hour, minute, second } => {  
            print!("The time is {}:", hour);
            println!("{}:{}", minute, second);  
        }  
    }  
}

結(jié)構(gòu)體大小

結(jié)構(gòu)體的大小在C/C++中使用運算符 sizeof 來計算；在Rust語言中，則使用標準庫中的一個模塊std::mem::中的size_of和size_of_val，它提供了與內(nèi)存管理相關(guān)的函數(shù)。

1. std::mem::size_of

用于計算給定類型的大小，不接受任何參數(shù)。這個函數(shù)返回一個給定類型的大?。ㄒ宰止?jié)為單位）。它是一個泛型函數(shù)，可以用于任何類型。

示例：

#![allow(dead_code)]

struct Point {
    x: i32,
    y: i32,
}  
  
struct Person {
    name: String,
    age: i32,
    height: f32,
    is_employed: bool,
}  
  
fn main() {
    let point = Point { x: 10, y: 20 };  
    println!("Size of Point: {}", std::mem::size_of::<Point>());

    let person = Person {
        name: "Hann Yang".to_string(),
        age: 50,
        height: 1.72,
        is_employed: true,
    };  
    println!("Size of Person: {}", std::mem::size_of::<Person>());
}

輸出：

Size of Point: 8
Size of Person: 40

2. std::mem::size_of_val

用于計算給定值的大小，接受一個值作為參數(shù)。它用于獲取一個值的大小（以字節(jié)為單位）。與 size_of 函數(shù)不同的是，size_of_val 函數(shù)可以用于任何值，而非類型。

示例：

#![allow(dead_code)]

struct Point {
    x: i32,
    y: i32,
}  
  
struct Person {
    name: String,
    age: i32,
    height: f32,
    is_employed: bool,
}  
  
fn main() {
    let point = Point { x: 10, y: 20 };  
    println!("Size of Point: {}", std::mem::size_of_val(&point));

    let person = Person {
        name: "Hann Yang".to_string(),
        age: 50,
        height: 1.72,
        is_employed: true,
    };  
    println!("Size of Person: {}", std::mem::size_of_val(&person));
}

輸出：

Size of Point: 8
Size of Person: 40

注意：在這兩個例子中，計算類型大小和值大小的結(jié)果都是相同的，因為這里沒有涉及到指針或其他復(fù)雜的情況。

本文總結(jié)

結(jié)構(gòu)體是Rust中一種重要的數(shù)據(jù)結(jié)構(gòu)，用于組織不同類型的字段。以下是結(jié)構(gòu)體的重點內(nèi)容的總結(jié)：

結(jié)構(gòu)體定義：使用struct關(guān)鍵字來定義結(jié)構(gòu)體，結(jié)構(gòu)體可以包含多個字段，每個字段可以有不同的類型。
結(jié)構(gòu)體實例：定義一個結(jié)構(gòu)體后，可以使用結(jié)構(gòu)體名稱來創(chuàng)建結(jié)構(gòu)體實例，通過.運算符來訪問結(jié)構(gòu)體字段。
結(jié)構(gòu)體分類：結(jié)構(gòu)體可以分為三種類型：單元結(jié)構(gòu)體（()）、元組結(jié)構(gòu)體（用逗號分隔的多個字段）和具名結(jié)構(gòu)體（有自定義名稱的字段）。
結(jié)構(gòu)體嵌套：結(jié)構(gòu)體可以嵌套，用于組織和存儲復(fù)雜的數(shù)據(jù)。
結(jié)構(gòu)體方法：結(jié)構(gòu)體可以定義方法，用于在結(jié)構(gòu)體上執(zhí)行操作。結(jié)構(gòu)體方法與關(guān)聯(lián)函數(shù)類似，但只能在結(jié)構(gòu)體上調(diào)用。
關(guān)聯(lián)函數(shù)：通過impl關(guān)鍵字在結(jié)構(gòu)體上定義關(guān)聯(lián)函數(shù)，用于在結(jié)構(gòu)體實例上執(zhí)行特定操作。關(guān)聯(lián)函數(shù)可以是普通函數(shù)或方法。
自定義打印宏：使用derive(Debug)]來自動實現(xiàn)fmt::Debug trait，實現(xiàn)自定義的打印輸出格式。
其他相關(guān)內(nèi)容：結(jié)構(gòu)體可以通過derive屬性來自動實現(xiàn)其他trait，如PartialEq（部分相等性）、Default（默認值）和Clone（克?。?。
結(jié)構(gòu)體大小：在Rust中，結(jié)構(gòu)體的內(nèi)存大小是固定的，可以在定義時指定大小，也可以使用#[repr(C)]來指定大小和布局。
模式匹配：可以使用模式匹配來訪問和匹配結(jié)構(gòu)體的字段，這使得在編寫代碼時更加靈活和方便。

總的來說，結(jié)構(gòu)體是Rust中非常強大和靈活的數(shù)據(jù)結(jié)構(gòu)，可以用于組織和操作各種類型的數(shù)據(jù)。通過使用結(jié)構(gòu)體、方法、關(guān)聯(lián)函數(shù)和其他相關(guān)特性，可以輕松地實現(xiàn)復(fù)雜的數(shù)據(jù)結(jié)構(gòu)和算法。

到此這篇關(guān)于Rust數(shù)據(jù)類型之結(jié)構(gòu)體Struct的使用的文章就介紹到這了,更多相關(guān)Rust 結(jié)構(gòu)體Struct內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: