Rust从入门到实战系列二百八十五：Derive 派生

我们可以使用 #[derive] 属性来派生一些特征，对于这些特征编译器会自动进行默认实现，对于日常代码
开发而言，这是非常方便的，例如大家经常用到的 Debug 特征，就是直接通过派生来获取默认实现，而无
需我们手动去完成这个工作。
想要查看更多信息，可以访问这里。
2. 🌟🌟
// Centimeters, 一 个 元 组 结 构 体 ， 可 以 被 比 较 大 小
#[derive(PartialEq, PartialOrd)]
struct Centimeters(f64);
// Inches, 一 个 元 组 结 构 体 可 以 被 打 印
#[derive(Debug)]
struct Inches(i32);
impl Inches {
fn to_centimeters(&self) -> Centimeters {
let &Inches(inches) = self;
Centimeters(inches as f64 * 2.54)
}
}
// 添 加 一 些 属 性 让 代 码 工 作
// 不 要 修 改 其 它 代 码 ！
struct Seconds(i32);
fn main() {
let _one_second = Seconds(1);
println!(“One second looks like: {:?}”, _one_second);
let _this_is_true = _one_second == _one_second;
let _this_is_true = _one_second > _one_second;
let foot = Inches(12);
println!(“One foot equals {:?}”, foot);
let meter = Centimeters(100.0);
let cmp =
if foot.to_centimeters() < meter {
“smaller”
} else {
“bigger”
bigger
};
println!(“One foot is {} than one meter.”, cmp);
}
运算符
在 Rust 中，许多运算符都可以被重载，事实上，运算符仅仅是特征方法调用的语法糖。例如 a + b 中的

• 是 std::ops::Add 特征的 add 方法调用，因此我们可以为自定义类型实现该特征来支持该类型的加法
  运算。

3. 🌟🌟
   use std::ops;
   // 实 现 fn multiply 方 法
   // 如 上 所 述 ，+ 需 要 T 类 型 实 现 std::ops::Add 特 征
   // 那 么, * 运 算 符 需 要 实 现 什 么 特 征 呢? 你 可 以 在 这 里 找 到 答 案: https://doc.rust-lang.org/co
   fn multiply
   fn main() {
   assert_eq!(6, multiply(2u8, 3u8));
   assert_eq!(5.0, multiply(1.0, 5.0));
   println!(“Success!”)
   }
4. 🌟🌟🌟
   // 修 复 错 误 ， 不 要 修 改 main 中 的 代 码!
   use std::ops;
   struct Foo;
   struct Bar;
   struct FooBar;
   struct BarFoo;
   // 下 面 的 代 码 实 现 了 自 定 义 类 型 的 相 加 ： Foo + Bar = FooBar
   impl ops::Add for Foo {
   type Output = FooBar;
   fn add(self, _rhs: Bar) -> FooBar {
   FooBar
   }
   }
   impl ops::Sub for Bar {
   type Output = BarFoo;
   fn sub(self, _rhs: Foo) -> BarFoo {
   BarFoo
   }
   }
   fn main() {
   // 不 要 修 改 下 面 代 码
   // 你 需 要 为 FooBar 派 生 一 些 特 征 来 让 代 码 工 作
   assert_eq!(Foo + Bar, FooBar);
   assert_eq!(Foo - Bar, BarFoo);
   println!(“Success!”)
   }