Rust數(shù)據(jù)類型之結構體Struct的使用
結構體（Struct）
是一種自定義數(shù)據(jù)類型，允許將多個相關的值組合在一起，形成一個更復雜的數(shù)據(jù)結構。結構體被廣泛應用于組織和管理數(shù)據(jù)，具有靈活性和強大的表達能力。
定義與聲明
結構體定義
在Rust中，定義和聲明結構體的語法如下：
struct Name {
field1: Type1,
field2: Type2,
// ...
fieldN: TypeN,
}其中，Name是結構體的名稱，每個數(shù)據(jù)名及其對應的數(shù)據(jù)類型組成一個字段，field1到fieldN是結構體的字段名稱，Type1到TypeN是字段的數(shù)據(jù)類型。
通過關鍵字 struct 定義，指定結構體名稱，結構體內用 field:type, 表示字段名稱及數(shù)據(jù)類型，注意rust語言不能在定義的同時進行賦值，且用逗號分隔各字段，不像c/c++用分號。
結構體中可以根據(jù)需要定義字段個數(shù)，理論上要多少就定義多少；但實際上字段太多，結構體也會變得很占空間，對程序的空間效率是個負擔。
結構體實例
如以下代碼定義了一個名為Point的結構體，包含x和y兩個字段，類型分別為i32和f64：
struct Point {
x: i32,
y: f64,
}定義結構體后，可以像使用其他類型一樣使用它。例如，可以聲明一個Point類型的變量，并為其字段賦值：
let my_point = Point { x: 10, y: 20.0 };使用結構體時，用成員運算符 my_point.x 來調用對應字段的值：
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)
}結構體分類
在Rust中，結構體（Struct）可以按照不同的方式進行分類，以下是一些常見的分類方式：
單元結構體（Unit Struct）
這種結構體沒有任何字段，它只是用于表示一個空的類型。這種結構體通常用于作為其他結構體的組成部分或返回類型。例如：
struct UnitStruct;
元組結構體（Tuple Struct）
這種結構體包含一組字段，可以通過元組語法來訪問每個字段。元組結構體可以用于表示簡單的數(shù)據(jù)集合，不使用大括號{}，而是使用元組的小括號()。例如：
struct TupleStruct(i32, String);
相當字段數(shù)據(jù)沒有名稱的結構體，訪問時使用索引。如：
struct Point (i32, f64);
fn main() {
let mut point = Point(10, 20.0);
point.0 = 5;
println!("({},{})", point.0, point.1);
}具名結構體（Named Struct）
這種結構體有一個顯式的名稱，并且包含一組字段。具名結構體可以用于表示復雜的數(shù)據(jù)結構，例如一個包含多個字段的對象，本文的示例大多數(shù)都為具名結構體，用法已在本文開頭講過：
struct MyStruct {
field1: i32,
field2: String,
// ...
}除了以上三種常見的結構體類型，Rust還支持其他特殊類型的結構體，例如帶有泛型參數(shù)的結構體、具名元組結構體（Named Tuple Struct）和結構體路徑（Struct Type Alias）等。
需要注意的是，在Rust中，結構體的分類并不是強制性的，也就是說，一個結構體可以包含任意類型的字段，并且可以在任何地方使用。這使得結構體非常靈活，可以用于實現(xiàn)各種復雜的數(shù)據(jù)結構。
結構體字段的數(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ù)自動調整大小。 - 浮點數(shù)類型（Floating-Point Number Types）：包括
f32和f64兩種類型，表示單精度和雙精度浮點數(shù)。 - 布爾類型（Boolean Type）：只有兩個取值，
true和false。 - 字符類型（Character Type）：表示單個 Unicode 字符，通常存儲為 4 個字節(jié)。
- 整數(shù)類型（Integer Types）：包括有符號整數(shù)類型和無符號整數(shù)類型。常見的整數(shù)類型有
復合類型（Composite Types）：
- 數(shù)組類型（Array Types）：由相同類型的元素組成的有限集合?？梢酝ㄟ^固定長度或動態(tài)長度來定義數(shù)組。
- 切片類型（Slice Types）：對一個連續(xù)的內存塊進行引用，可以看作是動態(tài)數(shù)組。切片類型提供了訪問和操作數(shù)據(jù)的一種高效方式。
- 元組類型（Tuple Types）：一種將多個不同類型的值組合在一起的數(shù)據(jù)結構，用圓括號和逗號分隔的元素序列表示。元組可以包含不同類型的元素，例如整數(shù)、浮點數(shù)、布爾值、字符串等。
- 結構體類型（Struct Types）：一種自定義的數(shù)據(jù)類型，可以包含多個不同類型的字段。結構體可以通過定義來指定其字段和屬性。
- 枚舉類型（Enum Types）：表示一個可能取多個值的變量。在 Rust 中，枚舉類型使用
enum關鍵字定義，每個可能的取值都是一個不同的枚舉成員。
結構體嵌套
一個結構體可以包含任意類型的字段，當然也包括結構體。
在以下這個例子中，Address 結構體包含了 street、city 和 state 三個字段，而 Person 結構體則包含了 name、age 和 address 三個字段，其中 address 字段的類型是 Address 結構體。
struct Address {
street: String,
city: String,
state: String,
}
struct Person {
name: String,
age: u8,
address: Address,
}結構體方法
方法（method）是在結構體上定義的功能，可以訪問結構體的字段并執(zhí)行一些操作。使用關鍵字impl，結構體可以對應一個或多個impl代碼塊。
例1：結構體轉換為字符串描述
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("東南大學");
let major = String::from("土木工程學院");
let s = Student{
name:String::from("楊程"),
age:22,
school,
major,
grade:String::from("大三"),
state:true
};
println!("{}", s.to_string());
}輸出：
Student { name: 楊程, age: 22, school: 東南大學, major: 土木工程學院, grade: 大三, state: true }
注意：上例中有一個rust結構體的特殊用法，使用同名變量在結構體外為對應字段賦值。
例2：矩形的周長和面積
struct Rectangle {
width: f32,
height: f32,
}
impl Rectangle {
// 構造函數(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：結構體字段的更新與輸出
struct Person {
name: String,
age: u32,
}
impl Person {
// 這是構造函數(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);
// 調用 say_hello 方法，輸出 Person 的信息
person.say_hello();
// 調用 update_age 方法，更新 Person 的年齡
person.update_age(3);
// 再次調用 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.
關聯(lián)函數(shù)
之所以"結構體方法"不叫"結構體函數(shù)"是因為"函數(shù)"這個名字留給了這種函數(shù)：它在 impl 塊中卻沒有 &self 參數(shù)。這種函數(shù)不依賴實例，但是使用它需要聲明是在哪個 impl 塊中的，比如上小節(jié)例2和例3中的構造函數(shù)new()就是關聯(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
結構體方法與關聯(lián)函數(shù)的區(qū)別
參數(shù)傳遞方式的區(qū)別
結構體方法：結構體方法默認情況下是可變的（mutable），也就是說可以修改結構體的字段。在調用方法時，可以通過引用（&self）或可變引用（&mut self）來傳遞結構體實例，以便修改其字段。例如：my_struct.my_method(&mut my_struct)。
關聯(lián)函數(shù)：關聯(lián)函數(shù)默認情況下是不可變的（immutable），也就是說無法修改結構體的字段。在調用函數(shù)時，只能通過常量引用（&self）來傳遞結構體實例，因為常量引用是只讀的。例如：let my_struct = MyStruct {...}; my_struct.my_function()。
使用方式的區(qū)別
結構體方法：結構體方法可以直接在結構體實例上調用，無需顯式傳遞結構體實例。例如：my_struct.my_method()。
關聯(lián)函數(shù)：關聯(lián)函數(shù)需要顯式傳遞結構體實例作為參數(shù)。例如：MyStruct::my_function(my_struct)。
結構體的trait
Rust 中的 trait 是一種抽象類型，用于定義泛型行為，trait 可以理解為一種接口。trait 使用關鍵字 derive 來自動生成實現(xiàn)。通過使用 derive，可以避免手動編寫冗長的代碼，提高代碼的可讀性和可維護性。trait 有很多，比如Copy，Clone，Debug，Default，Drop，Hash，Ord，PartialOrd，Send，Sync等等，先挑幾種最常用的學一下：
#[derive(Debug)]
在 Rust 語言中用于自動生成一個結構體的 Debug 實現(xiàn)，Debug 是 Rust 標準庫中的一個 trait，用于在控制臺打印調試信息。
使用 #[derive(Debug)] 屬性可以為結構體自動生成一個 Debug 實現(xiàn)，這樣在需要打印調試信息時，就可以使用 {:?} 格式化字符串來打印該結構體的內容。例如，在上面的代碼中，s 結構體的 Debug 實現(xiàn)已經(jīng)被自動生成，因此可以使用 println!("{:?}", s) 來打印出結構體 s 的內容。
例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("東南大學");
s.major = String::from("土木工程學院");
s.grade = String::from("大三");
s.state = true;
println!("{:?}", s);
}輸出：
Student { name: "楊程", age: 22, school: "東南大學", major: "土木工程學院", grade: "大三", state: true }
與上一小節(jié)的例2對比，輸出內容基本一致，就多了String的引號標記。相比自動生成 Debug 實現(xiàn)可以簡化代碼編寫過程，并且可以避免手動實現(xiàn) Debug 時可能出現(xiàn)的錯誤。
在本例中，使用宏打印結構體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； 調用：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("東南大學");
let major = String::from("土木工程學院");
let s = Student {
name: String::from("楊程"),
age: 22,
school,
major,
grade: String::from("大三"),
state: true,
};
println!("{:?}", s);
}輸出：
Student { name: 楊程, age: 22, school: 東南大學, major: 土木工程學院, grade: 大三, state: true }
2. impl fmt::Display for Student
返回值：fmt::Result； 調用：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)]為結構體自動實現(xiàn)了PartialEq trait。這使得可以直接使用==運算符比較兩個結構體實例的相等性。
例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)]
調用#[derive(Default)]，相當于創(chuàng)建一個默認的結構體實例，每一個字段都是對應數(shù)據(jù)類型的默認值，無需手動為每個字段設置默認值。
例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("東南大學");
s1.major = String::from("土木工程學院");
s1.grade = String::from("大三");
s1.state = true;
println!("{:?}", s1);
let s2 = Student {
age: 23,
grade: String::from("大四"),
..s1 //注意這里的結構體更新語法
};
println!("{:?}", s2);
}輸出：
Student { name: "", age: 0, school: "", major: "", grade: "", state: false }
Student { name: "楊程", age: 22, school: "東南大學", major: "土木工程學院", grade: "大三", state: true }
Student { name: "楊程", age: 23, school: "東南大學", major: "土木工程學院", grade: "大四", state: true }
此例還有一個rust結構體的特殊用法，當結構體大部分字段需要被設置成與現(xiàn)存的另一個結構體的一樣，僅需更改其中的一兩個字段的值，可以使用結構體更新語法，在現(xiàn)存的結構體名前加上兩個連續(xù)的句號：“..Struct_Name”。
#[derive(Clone)]
Clone 在復制過程中對所有字段進行逐個復制，包括所有引用類型和原始類型。這意味著每次進行克隆時，都會創(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
其他相關內容
模式匹配
結構體可用 模式匹配（Pattern Matching）來解構和訪問其字段。
例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);
}
}
}結構體大小
結構體的大小在C/C++中使用運算符 sizeof 來計算；在Rust語言中，則使用標準庫中的一個模塊std::mem::中的size_of和size_of_val，它提供了與內存管理相關的函數(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
注意：在這兩個例子中，計算類型大小和值大小的結果都是相同的，因為這里沒有涉及到指針或其他復雜的情況。
本文總結
結構體是Rust中一種重要的數(shù)據(jù)結構，用于組織不同類型的字段。以下是結構體的重點內容的總結：
- 結構體定義：使用
struct關鍵字來定義結構體，結構體可以包含多個字段，每個字段可以有不同的類型。 - 結構體實例：定義一個結構體后，可以使用結構體名稱來創(chuàng)建結構體實例，通過
.運算符來訪問結構體字段。 - 結構體分類：結構體可以分為三種類型：單元結構體（
()）、元組結構體（用逗號分隔的多個字段）和具名結構體（有自定義名稱的字段）。 - 結構體嵌套：結構體可以嵌套，用于組織和存儲復雜的數(shù)據(jù)。
- 結構體方法：結構體可以定義方法，用于在結構體上執(zhí)行操作。結構體方法與關聯(lián)函數(shù)類似，但只能在結構體上調用。
- 關聯(lián)函數(shù)：通過
impl關鍵字在結構體上定義關聯(lián)函數(shù)，用于在結構體實例上執(zhí)行特定操作。關聯(lián)函數(shù)可以是普通函數(shù)或方法。 - 自定義打印宏：使用
derive(Debug)]來自動實現(xiàn)fmt::Debugtrait，實現(xiàn)自定義的打印輸出格式。 - 其他相關內容：結構體可以通過
derive屬性來自動實現(xiàn)其他trait，如PartialEq（部分相等性）、Default（默認值）和Clone（克隆）。 - 結構體大?。涸赗ust中，結構體的內存大小是固定的，可以在定義時指定大小，也可以使用
#[repr(C)]來指定大小和布局。 - 模式匹配：可以使用模式匹配來訪問和匹配結構體的字段，這使得在編寫代碼時更加靈活和方便。
總的來說，結構體是Rust中非常強大和靈活的數(shù)據(jù)結構，可以用于組織和操作各種類型的數(shù)據(jù)。通過使用結構體、方法、關聯(lián)函數(shù)和其他相關特性，可以輕松地實現(xiàn)復雜的數(shù)據(jù)結構和算法。
到此這篇關于Rust數(shù)據(jù)類型之結構體Struct的使用的文章就介紹到這了,更多相關Rust 結構體Struct內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要介紹了Rust寫個猜數(shù)字游戲,本項目通過動手實踐,介紹了Rust新概念：let、match、函數(shù)、使用外部 crate 等,接下來的文章,你會繼續(xù)深入學習這些概念,并且介紹大部分編程語言都有的概念,如變量、數(shù)據(jù)類型和函數(shù),以及如何在 Rust 中使用它們,需要的朋友可以參考下2023-12-12
Vector在Rust中是一個非常靈活和強大的數(shù)據(jù)結構,通過有效利用它,我們可以更加方便地處理和操作多個值,使得代碼更加清晰和易于維護,這篇文章主要介紹了Rust中的Vector多值存儲的利器,需要的朋友可以參考下2024-02-02
這篇文章主要介紹了Rust 智能指針的實現(xiàn)方法,本文給大家介紹的非常詳細,對大家的學習或工作具有一定的參考借鑒價值,需要的朋友參考下吧2024-01-01
這篇文章主要為大家詳細介紹了Rust中的枚舉和模式匹配的相關知識,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下2024-01-01
Rust?Atomics?and?Locks內存序Memory?Ordering詳解
這篇文章主要為大家介紹了Rust?Atomics?and?Locks內存序Memory?Ordering詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-02-02
Rust是類型安全的語言，因此在Rust中做類型轉換不是一件簡單的事，本文主要介紹了rust類型轉換的實現(xiàn)，具有一定的參考價值，感興趣的可以了解一下2023-12-12
這篇文章主要介紹了使用Rust制作康威生命游戲,初始rust項目，使用wasm的項目模板，結合實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2022-09-09
anyhow 是 Rust 中的一個庫,旨在提供靈活的、具體的錯誤處理能力,建立在 std::error::Error 基礎上,主要用于那些需要簡單錯誤處理的應用程序和原型開發(fā)中,本文給大家分享Rust anyhow 簡明教程,一起看看吧2024-06-06
Rust模塊化，模塊化有助于代碼的管理和層次邏輯的清晰，本文主要介紹了Rust如何進行模塊化開發(fā),結合實例代碼給大家講解的非常詳細，需要的朋友可以參考下2023-01-01
Rust標準庫中并沒有隨機數(shù)生成器,常見的解決方案是使用rand包,本文主要介紹了Rust生成隨機數(shù)的項目實踐,具有一定的參考價值,感興趣的可以了解一下2024-03-03