结构体(struct)可以将多个不同类型的数据命名并包装起来,将它们组合成一个有特殊意义的群组,就像是面向对象概念中的对象所拥有的属性。在这个章节中我们将会比较元组和结构体的差异、学习如何使用结构体,并替结构体定义方法(method)和关联函数(associated function)。
结构体和我们先前讨论过的元组还蛮相像的,都可以保存不同类型的数据。只不过,结构体会将每个数据命名,让我们明确知道每个数据字段(field)的用途,而不必去考虑字段的顺序。定义一个结构体,可以使用 struct 关键字,用法如下:
struct 结构名称 {
字段1名称: 字段1的类型,
字段2名称: 字段2的类型,
字段3名称: 字段3的类型,
字段n名称: 字段n的类型,
}
举例来说:
struct User {
username: String,
email: String,
sign_in_count: u64,
active: bool,
}
定义好结构体之后,就可以将这个结构体作为一个类型来使用。结构体所产生出来的值,即为这个结构的「实体」(instance),要产生出结构实体,必须要将结构体「实体化」。举例来说:
struct User {
username: String,
email: String,
sign_in_count: u64,
active: bool,
}
fn main() {
let user1 = User {
email: String::from("someone@example.com"),
username: String::from("someusername123"),
active: true,
sign_in_count: 1,
};
}
实体化一个结构体和定义一个结构体的时候很像,都需要撰写结构名称和这个结构的所有字段。在实体化结构体的时候,必须直接在 : 后面指派字段的值,而非撰写字段的类型。以上代码的第 9 行到第 14 行,透过赋予值给 User 结构的每个字段,来创建出一个 User 结构的实体,并指派给刚被声明出来的 user1 变量保存。
如果要访问结构体的字段,可以用 . 语法。举例来说:
struct User {
username: String,
email: String,
sign_in_count: u64,
active: bool,
}
fn main() {
let mut user1 = User {
email: String::from("someone@example.com"),
username: String::from("someusername123"),
active: true,
sign_in_count: 1,
};
user1.email = String::from("anotheremail@example.com");
}
程序第 16 行,将新的字符串结构实体指派给 user1 的 email 字段。由于 user1 变量的值本身需要可以被改变,因此在第 9 行声明 user1 变量的时候要使用 mut 关键字。这边要注意的是,结构体无法指定其哪些字段可变、哪些字段不可变,只要没有用 mut 声明变量,就是都不可变;有用 mut 声明变量,就是都可以变。
在实体化出结构体的时候,必须要指派所有字段的值。可是这样在使用上很不方便,若有些字段在实体化的时候所用的值是固定的,每次进行实体化的时候都要写一样的程序。Rust 的结构体并无法直接定义初始值,因此如果想要让结构体的某些字段在实体化时是选填的话,可以透过实作一个创建出该结构体实体的函数来供以后重复使用。
举例来说:
struct User {
username: String,
email: String,
sign_in_count: u64,
active: bool,
}
fn build_user(email: String, username: String) -> User {
User {
email: email,
username: username,
active: true,
sign_in_count: 1,
}
}
fn main() {
let user1 = build_user(String::from("someone@example.com"), String::from("someusername123"));
}
透过 build_user 函数,每次要实体化出 User 结构的时候,只要填写 email 和 username 字段即可。但以上程序写起来似乎还是有点麻烦,程序第 10 行和第 11 行,分别写了 email: email 和 username: username,看起来很冗长。Rust 在这里提供了一个方便的语法糖,当变量名称和字段名称相同的时候,可以省略撰写字段名称,直接填入变量名称即可。修改后的程序如下:
struct User {
username: String,
email: String,
sign_in_count: u64,
active: bool,
}
fn build_user(email: String, username: String) -> User {
User { email, username, active: true, sign_in_count: 1 }
}
fn main() {
let user1 = build_user(String::from("someone@example.com"), String::from("someusername123"));
}
另外还有一个语法糖称作「结构更新语法」,可以直接以现有的相同结构实体部份或全部的字段值来产生新的结构实体。举例来说:
struct User {
username: String,
email: String,
sign_in_count: u64,
active: bool,
}
fn build_user(email: String, username: String) -> User {
User { email, username, active: true, sign_in_count: 1 }
}
fn main() {
let user1 = build_user(String::from("someone@example.com"), String::from("someusername123"));
let user2 = User {
email: String::from("another@example.com"),
username: String::from("anotherusername567"),
active: user1.active,
sign_in_count: user1.sign_in_count,
};
}
以上程序第 17 行和第 18 行可以直接简化成:
struct User {
username: String,
email: String,
sign_in_count: u64,
active: bool,
}
fn build_user(email: String, username: String) -> User {
User { email, username, active: true, sign_in_count: 1 }
}
fn main() {
let user1 = build_user(String::from("someone@example.com"), String::from("someusername123"));
let user2 = User {
email: String::from("another@example.com"),
username: String::from("anotherusername567"),
..user1
};
}
我们也可以定义出如以下这样的结构体:
struct Color(i32, i32, i32);
这种结构体称作「元组结构体」(tuple struct),说穿了就是将原本的元组多加上结构名称,也就是能自订类型名称的元组,用法也跟一般的元组一样。将「元组结构体」实体化的语法和一般的结构体类似,就是原本定义出结构体的语法,只不过要把字段类型改成字段的值。如下:
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);
let t = (0, 0, 0);
上面这个例子要注意的是,虽然 black 变量、origin 变量和 t 变量的元组都是 (i32, i32, i32),但由于 black 变量、origin 变量是属于「元组结构体」类型,只要不是来自于相同的结构体,就是属于不同的类型。换句话说,black 变量、origin 变量和 t 变量都是使用不同的类型。
我们可以定义不包含任何字段,也不写任何括号的结构体,这种结构体称为「类单元结构体」(unit-like struct),也可以简称为「单元结构体」(unit struct)。这种结构体常会和其它特性一同使用,以面向对象的观念来解释的话就是「没有对象属性,只有方法的类别」,举例来说:
struct Tools;
trait Array {
fn print_array(a: &[i32]);
}
trait Helper {
fn show_help();
}
impl Array for Tools {
fn print_array(a: &[i32]) {
println!("{a:?}");
}
}
impl Helper for Tools {
fn show_help() {
println!("Struct Tools is a set of functions dealing with common things.");
}
}
fn main() {
let a = [1, 2, 3];
Tools::show_help();
Tools::print_array(&a);
}
程序第 1 行定义了没有任何字段的结构体 Tools。程序运行结果为:
[1, 2, 3]
如果现在还不了解 trait、impl 关键字没有关系,之后会做更深入的介绍,在此只要有个「结构体可以没有数据字段」的概念就好。
接着我们来使用结构体练习实际的程序案例:制作出一个可以计算矩形面积的程序。
首先,使用 Cargo 创建名为 rectangles 的项目。接着先用最简单的方式,不使用结构体来撰写出以下计算矩形面积的程序:
fn main() {
let width1 = 30;
let height1 = 50;
println!("The area of the rectangle is {} square pixels.", area(width1, height1));
}
fn area(width: u32, height: u32) -> u32 {
width * height
}
area 函数可以传入矩形的宽和高,计算并回传矩形的面积。以上程序运行结果如下:
这个程序很简单,但是会有个令人疑惑的地方。我们在前面的章节不是提到直接写在代码的整数是 i32 类型吗?为什么这边使用 u32 是可以通过编译的呢?这个状况跟之前提到的在使用 let 关键字时明确定义数值类型的方式有点类似,只不过我们现在是将明确定义数值类型的地方放在第一次使用这个数值时。在这个计算面积的例子中,width1 和 height1 变量在声明时并没有明确定义出数值是用哪个类型,但是它们第一次都被使用在调用 area 函数时代入的 u32 类型的参数,编译器就会在编译阶段自动将 width1 和 height1 变量当作是 u32 类型。
接着使用之前学到的元组,尝试改写这个计算矩形面积的程序:
fn main() {
let rect1 = (30, 50);
println!("The area of the rectangle is {} square pixels.", area(rect1));
}
fn area(dimensions: (u32, u32)) -> u32 {
dimensions.0 * dimensions.1
}
我们将元组 (u32, u32) 的索引 0 字段定义为矩形的宽,索引 1 的字段定义为矩形的高。这样的作法虽然可以少写一些代码,却可能会造成字段上的误解,虽然这个例子是计算矩形面积,长宽顺序错了也没关系。
为了让程序的可读性更高,我们选择使用结构体来改写程序。如下:
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let rect1 = Rectangle { width: 30, height: 50 };
println!("The area of the rectangle is {} square pixels.", area(&rect1));
}
fn area(rectangle: &Rectangle) -> u32 {
rectangle.width * rectangle.height
}
程序第 1 行到第 4 行,定义了 Rectangle 结构。接着在 main 函数中创建出 Rectangle 结构的实体,并以参考的方式传递给 area 函数使用,这样才不会造成 Rectangle 结构实体的拥有权被 area 函数的参数拿走。
如果将我们创建出来的结构实体放进 println! 宏中使用会发生什么事呢?如以下程序:
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let rect1 = Rectangle { width: 30, height: 50 };
println!("rect1 is {rect1}");
}
程序第 9 行会编译错误,因为 Rectangle 结构并未实作 std::fmt 模块底下的 Display 特性。
那如果是跟印出数组或是元组的方式一样,在大括号内加上 :? 呢?程序如下:
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let rect1 = Rectangle { width: 30, height: 50 };
println!("rect1 is {rect1:?}");
}
程序第 9 行还是会编译错误,因为 Rectangle 结构并未实作 std::fmt 模块底下的 Debug 特性。Debug 特性顾名思义是用来给程序开发者查看值的内容到底是什么,我们可以自行实作将结构体转成字符串的方式,或是采用 Rust 编程语言内置的语法糖 #[derive(Debug)] 来快速让我们的结构体实作 Debug 特性。只要在想要使用内置的方式实作 Debug 特性的结构体定义程序上,加上一行 #[derive(Debug)] 即可。如下:
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let rect1 = Rectangle { width: 30, height: 50 };
println!("rect1 is {rect1:?}");
}
程序运行结果为:
加上 #[derive(Debug)] 的结构体就可以透过 :? 语法来印出。
学会如何检查结构实体的字段名称和值之后,我们要来开始替结构体撰写「方法」(method)啦!「方法」类似「函数」,也是一样使用 fn 关键字来定义,只不过原先定义函数参数的地方,第一个参数必须要是 &self,用来表示结构实体自身。使用 fn 关键字定义结构体的方法,并不是写在 struct 关键字的区块,而是要使用另外一个关键字 impl。举例来说:
#[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());
}
以上程序第 7 行到第 11 行,使用 impl 来定义并实作 Rectangle 结构的 area 方法,area 方法会利用 Rectangle 结构实体自身的 width 和 height 字段来计算并回传面积。在 impl 关键字所组成的程序区块中,self 即为结构实体本身,将 self 代入参数的话会造成结构实体的拥有权被参数拿走,因此必须要使用 &self 来传递。
在 impl 中使用 fn 关键字不一定要将第一个参数设为 &self,如此一来定义出来的就是这个结构体关联的函数(associated function)。举例来说:
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
fn new(width: u32, height: u32) -> Rectangle {
Rectangle { width, height }
}
}
fn main() {
let rect1 = Rectangle::new(30, 50);
println!("The area of the rectangle is {} square pixels.", rect1.area());
}
以上程序第 12 行到第 14 行,我们定义了一个 Rectangle 结构的关联函数 new,可以透过 new 函数的参数来将矩形的长宽值传入,并创建出一个 Rectangle 结构的实体。在调用结构体的函数时,不需要实体化结构体,只要使用结构体的名称,再接上 :: 语法与要调用的函数名称;而在调用结构体的方法时,必须要先将结构体实体化,再用结构实体接上 . 与要调用的方法名称。
如果结构实体的方法会改变结构实体本身的值,在用 fn 关键字定义方法的时候,第一个参数必须改为 &mut self。举例来说:
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
fn set_width(&mut self, width: u32) {
self.width = width;
}
fn new(width: u32, height: u32) -> Rectangle {
Rectangle { width, height }
}
}
fn main() {
let mut rect1 = Rectangle::new(30, 50);
rect1.set_width(10);
println!("The area of the rectangle is {} square pixels.", rect1.area());
}
以上程序第 12 行到第 14 行,我们定义了一个 Rectangle 结构的方法 set_width,这个 set_width 方法可以设置 Rectangle 结构实体的 width 字段。程序第 24 行,调用了 rect1 结构实体的 set_width 方法,因此 rect1 结构实体的 width 字段的值会发生改变。
同一个结构体可以使用多个 impl 关键字来定义其方法和关联函数,非常自由,也可以利用多个 impl 关键字来替结构体实作出不同的特性。
稍微把我们刚才写的 Rectangle 结构体扩充一些功能,程序如下:
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn square(size: u32) -> Rectangle {
Rectangle { width: size, height: size }
}
fn new(width: u32, height: u32) -> Rectangle {
Rectangle { width, height }
}
}
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
}
}
impl Rectangle {
fn set_width(&mut self, width: u32) {
self.width = width;
}
fn set_height(&mut self, height: u32) {
self.height = height;
}
}
fn main() {
let rect1 = Rectangle::new(30, 50);
println!("The area of the rectangle is {} square pixels.", rect1.area());
}
总结
结构体让我们可以创建出有特别意义的自订类型,数据的群组化与各种相关操作的链接使我们的代码变得更容易读写。在下一章节中,将会介绍另外一种也是能让代码更好撰写、更容易阅读的类型种类──枚举(enum)。
下一章:枚举和型样匹配。
