结构体

在 User 结构体的定义中，使用了 自身拥有所有权 的 String 类型 而不是 &str 字符串 slice 类型 。这是一个有意而为之的选择，因为想要这个 结构体拥有它所有的数据 ，为此 只要整个结构体是有效的话其数据也是有效的

     可以使结构体存储被其他对象拥有的数据的引用，不过这么做的话需要用上“生命周期”

     生命周期确保“结构体引用的数据有效性”跟 “结构体本身”保持一致

如果尝试在结构体中存储一个 引用 而 不指定生命周期 将是无效的，比如这样：

struct User {
    username: &str,
    email: &str,
    sign_in_count: u64,
    active: bool,
}

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

编译器会报错：

error[E0106]: missing lifetime specifier
 --> src/main.rs:2:15
  |
2 |     username: &str,
  |               ^ expected lifetime parameter

error[E0106]: missing lifetime specifier
 --> src/main.rs:3:12
  |
3 |     email: &str,
  |            ^ expected lifetime parameter

error: aborting due to 2 previous errors

For more information about this error, try `rustc --explain E0106`.
error: could not compile `reference_without_lifetime`.

下面展示了使用 元组 的另一个程序版本：

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
}

在某种程度上说，这个程序更好一点了。元组帮助增加了一些结构性，并且现在只需传一个参数。不过在另一方面，这个版本却有一点不明确了：元组并 没有给出元素的名称 ，所以计算变得更费解了，因为 不得不使用索引 来获取元组的每一部分

     在计算面积时将宽和高弄混倒无关紧要，不过当在屏幕上绘制长方形时就有问题了！
     必须牢记 width 的元组索引是 0，height 的元组索引是 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
}

• 定义了一个结构体并称其为 Rectangle：
  • 在大括号中定义了字段 width 和 height，类型都是 u32
• 在 main 中，创建了一个具体的 Rectangle 实例
  • 它的宽是 30，高是 50

函数 area 现在被定义为接收一个名叫 rectangle 的参数，其类型是一个 结构体 Rectangle 实例 的 不可变借用 ，这样 main 函数就可以保持 rect1 的所有权 并继续使用它，这就是为什么在 函数签名 和 调用 的地方会有 &

area 函数访问 Rectangle 实例的 width 和 height 字段

area 的函数签名现在明确的阐述了我们的意图：使用 Rectangle 的 width 和 height 字段，计算 Rectangle 的面积

这表明宽高是相互联系的，并为这些值提供了描述性的名称而不是使用元组的索引值 0 和 1

结构体胜在更清晰明了！

把前面实现的获取一个 Rectangle 实例作为参数的 area 函数，改写成一个定义于 Rectangle 结构体上的 area 方法，如下所示：

#[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()
    );
}

• 为了使函数定义于 Rectangle 的上下文中：开始了一个 impl 块
• 将 area 函数移动到 impl 大括号中
  • 将签名中的 第一个参数 和函数体中其他地方的对应参数改成 self
• 在 main 中将先前调用 area 方法并传递 rect1 作为参数的地方，改成在 Rectangle实例 rect1 上调用 方法语法 area：
  • 方法语法：获取一个 实例 并加上一个 点 号，后跟 方法名 、 圆括号 以及 任何参数

     在 area 的签名中，使用 &self 来替代 rectangle: &Rectangle

     因为该方法位于 Rectangle 的 impl上下文 中，所以编译器知道 self 的类型是 Rectangle

注意：仍然需要在 self 前面加上 & ，就像 &Rectangle 一样。self参数和其他参数一样可以选择：

1. 获取 self 的所有权
2. 像这里一样不可变地借用 self
3. 可变地借用 self

     这里选择 &self 的理由跟在函数版本中使用 &Rectangle 是相同的：并不想获取所有权，只希望能够读取结构体中的数据，而不是写入

如果想要在 方法中 改变 调用方法的 实例 ，需要将第一个参数改为 &mut self

     通过仅仅使用 self 作为第一个参数来使方法获取实例的所有权是很少见的：

     这种技术通常用在当方法将 self 转换成别的实例的时候，这时想要防止调用者在转换之后使用原始的实例

使用方法替代函数，除了可使用方法语法和不需要在每个函数签名中重复 self 的类型之外，其主要好处在于 组织性

     将某个类型实例能做的所有事情都一起放入 impl 块中，而不是让将来的用户在库中到处寻找 Rectangle 的功能

     现在在Rectangle结构体的上下文中定义另一个方法：首先获取另一个 Rectangle 实例

     如果 self 能完全包含第二个长方形则返回 true；否则返回 false

一旦定义了 can_hold 方法，就可以编写下面中的代码：

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

同时希望看到如下输出，因为 rect2 的两个维度都小于 rect1，而 rect3 比 rect1 要宽：

Can rect1 hold rect2? true
Can rect1 hold rect3? false

如果想定义一个方法，它应该位于 impl Rectangle 块中，方法名是 can_hold，它会获取另一个 Rectangle 的不可变借用作为参数

通过观察调用方法的代码可以看出参数是什么类型的：rect1.can_hold(&rect2) 传入了 &rect2，它是一个 Rectangle 的实例 rect2 的不可变借用
1. 因为只需要读取 rect2（而不是写入，这意味着需要一个不可变借用）
2. 希望 main 保持 rect2 的所有权，这样就可以在调用这个方法后继续使用它

can_hold 的返回值是一个布尔值，其实现会分别检查 self 的宽高是否都大于另一个 Rectangle

在 impl 块中增加这个新的 can_hold 方法：

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
    }
}

在方法签名中，可以在 self 后增加多个参数，而且这些参数就像函数中的参数一样工作

impl 块的另一个有用的功能是：允许在 impl 块中定义 不以 self 作为参数 的函数。这被称为 关联函数 ，因为它们与结构体相关联

     它们仍是函数而不是方法，因为它们并不作用于一个结构体的实例

     就像已经使用过 String::from 关联函数了

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

     例如可以提供一个关联函数，它接受一个维度参数并且同时作为宽和高

     这样可以更轻松的创建一个正方形 Rectangle 而不必指定两次同样的值

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

使用 结构体名 和 :: 语法来 调用 这个 关联函数 比如：

let sq = Rectangle::square(3);

     这个方法位于结构体的命名空间中，'::' 语法用于关联函数和模块创建的命名空间

每个结构体都 允许 拥有 多个 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 块中，不过这是有效的语法

     以后讨论泛型和 trait 时会看到实用的多 impl 块的用例