The Rust Programming Language - 第5章 使用结构体组织相关数据

5 使用结构体组织相关数据

struct 是一个自定义的数据类型，允许你命名和包装多个相关的值，从而形成一个更有意义的组合

5.1 定义并实例化结构体

同元组一样，结构体中每个成员的数据类型可以是不同，但是结构体命名更加的清楚和明确，数据的名字和类型称为字段

结构体的定义：

struct User {
    username :String,
    email:String,
    sign_in_count:u64，
    active:bool，
}

结构体的实例化：

let user1 = User {
    email: String::from("someone@example.com"),
    username: String::from("someusername123"),
    active:true,
    sign_in_count:1,
}

改变User 实例email字段值，注意;整个结构体必须是可变的

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");

在函数中使用结构体

fn build_user (email:String,username:String) -> User{
    User{
        username :String,
        email:String,
        sign_in_count:true,
        active:1,
    }
}

变量与字段同命时字段初始化简写语法

fn build_user (email:String,username:String) -> User{
    User{
        username,
        email,
        sign_in_count:true,
        active:1,
    }
}

结构体更新

let user2 = User{
    active:user1.active,
    username:user1.username,
    sign_in_count:user1.sign_in_count,
    email:String::from("anotherone@example.com")
}//不使用更新语法

let user2 = User {
    email:String::from("anotherone@example.com"),
    ..user1
}//使用更新语法..user1

注意，解构体更新语法类似 = 的赋值，因为它移动了数据，这个概念我们在前面变量与数据的交换方式：移动和克隆中讲过，知识点有模糊的朋友看前面啊

元组结构体

元组结构体没有具体的字段名，只有字段的类型

定义元组结构体，如下结构体尽管字段类型相同，但是结构体类型业不同

struct Color (i32,i32,i32);
struct Point(i32,i32,i32);

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

类单元结构体

类单元结构体中没有任何字段，类似于（），即“元组类型”一节 中提到的unit类型

类单元结构体常常在你想要某个类型上实现trait但不需要在类型中存储数据的时候发挥作用

struct AlwaysEqual;
let subject = AlwaysEqual;

结构体数据的所有权

我们现在使用了自身拥有所有权的String类型而不是&str字符串slice类型

5.2 一个使用结构体的示例程序

我们来写一个计算长方形面积的小程序

fn main() {
    let width1 = 30;
    let heigth1 = 50;

    println!("The area of the retangle is {} square pixels.",
        area(width1,heigth1)
    );
}
fn area (width:u32,heigth:u32) -> u32{
    width*heigth
}

长方形的长和宽是有关系的，我们来重构一下，我们将两个变量放入了一个元组

fn main() {
   let rect1 = (30,50);

   println!("The area if rectangle is {} square pixels",
        area(rect1)
    );
}
fn area (dimensions:(u32,u32)) -> u32{
    dimensions.0*dimensions.1
}

虽然使用元组可以将元素关联起来，但是我们仍然无法判断它们到底代表什么，我接下来用结构体重构，赋予他们更多意义

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

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

   println!("The area if rectangle is {} square pixels",
        area(&rect1)
    );
}
fn area (rectangle:&Rectangle) -> u32{
    rectangle.width*rectangle.height
}

参数形式的不同，处理其的函数形式也要跟着变化

通过派生trait来增加其他功能；增加属性来派生 Debug trait，并使用调试格式打印 Rectangle 实例

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

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

   println!("The rect1 is: {:?}",rect1);//Rectangle { width: 30, height: 50 }
}

另一种使用debug格式打印数值的方法是使用dbg!宏。dbg!宏接收一个表达式的所有权，打印出你代码中dbg！宏调用的文件或行号，以及该表达式的结果值，并返回该值所有权.调用dbg!宏会打印到标准错误控制台流（stderr）和（stdout）

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

fn main() {
    let scale = 2;
    let rect1 = Rectangle {
        width: dbg!(30 * scale),
        height: 50,
    };

    dbg!(&rect1);
}

除了Debug trait，Rust还为我们提供了很多可以通过derive属性来使用的trait，他们可以为我们的自定义类型增加实用的行为

5.3 方法语法

area函数其实非常特殊，只能用来计算长方形的面积，让我们来重构代码，将area函数协调进Rectangle类型定义阿area方法中

方法与函数类似，使用fn关键字声明，可以拥有参数和返回值，同时包含在某处调用该方法时会执行的代码。不过方法和函数是不同的，方法在结构体上下文中被定义，第一个参数总是self，它代表调用该方法的结构体实例

定义方法

让我们把之前的area函数改为定义于Rectangle结构体上的area方法

#[derive(Debug)]
struct Rectangle {
    width: u32,
    heigth: u32,
}
impl Rectangle {// 我们开始了一个impl块，后面接块名称（Rectangle），因此块中所有内容都与Rectangle类型相关
    fn area(&self) -> u32 {//定义了一个方法，参数是&self（也可是self或者可变借用）,代替了rectangle: &Rectangle
        self.width*self.heigth
    }
}
fn main() {
    let rect1 = Rectangle {width:30,heigth:50};

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );
}

通过使用self作为第一参数来让方法获取实例的所有权是非常少见的，这种做法一般是用方法将self转换成别的示例的时候，这个时候我们需要防止调用者在转换后仍然使用原始实例

使用方法的好处：我们可以将某个类型实例能做的事情都放入impl 块，而不是让将来的用户在我们的库中到处寻找Rectangle的功能

我们在某个类型的块中定义方法，这个方法名可以和类型中的字段相同，如下：

#[derive(Debug)]
struct Rectangle {
    width: u32,
    heigth: u32,
}
impl Rectangle {
    fn width(&self) -> bool {
        self.width>0
    }
}
fn main() {

    let rect1 = Rectangle {
        width:30,
        heigth:50,
    };

    if rect1.width() {
        println!("The retangle has a nonezero with; it is {}",rect1.width);
    }
}

运算符去哪里了

Rust 有一个叫 自动引用和解引用（automatic referencing and dereferencing）的功能

工作原理：当使用 object.something() 调用方法时，Rust 会自动为 object 添加 &、&mut 或 * 以便使 object 与方法签名匹配

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

带有多个参数的方法

#[derive(Debug)]

struct Rectangle {
    width: u32,
    height: u32,
}
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
    }    
}
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));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}

关联函数

在impl块中定义的函数称为关联函数，因为它们与impl后面的类型相关。String::from函数就是在String类型上定义的函数

关联函数经常被用作返回一个结构体新实例的构造函数

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

多个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语法，但这是有效的语法

总结：结构体让我们可以创建出在我们的领域中有意义的自定义类型。通过结构体，我们可以将相关联的数据片段联系起来并命名它们，这样可以使得代码更加清晰。在 impl 块中，我们可以定义与我们的类型相关联的函数，而方法是一种相关联的函数，让我们指定结构体的实例所具有的行为

但结构体并不是创建自定义类型的唯一方法，下一章，我们将会了解枚举的功能