我们可以使用 #[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 方法调用,因此我们可以为自定义类型实现该特征来支持该类型的加法
运算。
- 🌟🌟
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!”)
} - 🌟🌟🌟
// 修 复 错 误 , 不 要 修 改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!”)
}