已备案网站数量,学生个人网页内容排版设计作品,拼多多电商代运营可信吗,e4a做网站app要重载比较运算符#xff0c;需要为类型实现对应的trait。 重载和!#xff0c;需要实现PartialEq或者Eq 重载、、 、 #xff0c;需要实现PartialOrd或者Ord
一、Eq/PartialEq
为什么有两个trait呢#xff1f; 因为相等关系有两种#xff1a;一种是完全…要重载比较运算符需要为类型实现对应的trait。 重载和!需要实现PartialEq或者Eq 重载、、 、 需要实现PartialOrd或者Ord
一、Eq/PartialEq
为什么有两个trait呢 因为相等关系有两种一种是完全相等关系一种是部分相等关系。 完全相等关系满足如下三个性质 自反性自己一定等于自己即aa 对称性若有ab则有ba 传递性若有ab和bc则有ac
部分相等关系只满足两个性质 对称性若有ab则有ba 传递性若有ab和bc则有ac
在浮点数类型中有个特殊的值是NaNNot-a-number这个值与任何值都不等包括自己NaN ! NaN它就违背了自反性。所以判断浮点数是否相等就只能使用部分相等关系。
部分相等是全相等关系的子集也就是说如果两个元素具有全相等关系那它们之间也一定有部分相等关系。
一PartialEq
是部分相等关系。 这个Trait中定义了两个方法
pub Trait PartialEqRhs: ?Sized Self {fn eq(self, other: Rhs) - bool;fn ne(self, other: Rhs) - bool {!self.eq(other)}
}eq两个值相等的话就返回true需要使用者自行重载 ne两个值不相等的话就返回true默认已经实现了
所有的基本类型都实现了PartialEq
1.为自定义类型实现PartialEq 可使用#[derive(PartialEq)]由编译器自动实现 #[derive(PartialEq)] pub struct Person {pub id: u32,pub name: String,pub height: f64,
}也可以自己手动实现
impl PartialEq for Person {fn eq(self, other: Self) - bool {self.id other.id}
}实现时只需要实现eq方法即可ne我们使用默认的。
实现了PartialEq就自动重载了和!运算符下面就可以判断是否相等了
fn main() {let p1 Person {id: 0,name: John.to_string(),height: 1.2,};let p2 Person {id: 0,name: Jack.to_string(),height: 1.4,};println!(p1 p2 {}, p1 p2); // p1 p2 true
}例子
fn main() {let f1 f32::NAN;let f2 f32::NAN;if f1 f2 {println!(NaN竟然可以比较这很不数学啊)} else {println!(果然虽然两个都是NaN但是它们其实并不相等)}
}2.比较不同的类型 给Rhs传入不同的类型就能比较不同类型的相等性。 示例代码如下
#[derive(PartialEq)]
enum WheelBrand { Bmw, Benz, Michelin,
}
struct Car { brand: WheelBrand, price: i32,
}
impl PartialEqWheelBrand for Car {fn eq(self, other: WheelBrand) - bool { self.brand *other }
}
fn main() {let car Car { brand: WheelBrand::Benz, price: 10000 };let wheel WheelBrand::Benz; // 比较struct和enumassert!(car wheel);// assert!(wheel car); // 无法反过来比较
}代码仅实现了Car与Wheel的相等性比较若要反过来比较还得提供反向的实现如下
impl PartialEqCar for WheelBrand {fn eq(self, other: Car) - bool {*self other.brand }
}二Eq
就是完全相等关系
这个trait继承了PartialEq但没有添加新的方法这个Trait只是告诉编译器这是个完全相等关系而非部分相等关系。
pub Trait EqPartialEq{}在标准库中只有f32和f64没有实现Eq
1.为自定义类型实现Eq 实现Eq不需要额外的代码只需要实现PartialEq并添加#[derive(Eq)]就可以了。
实现了Eq的类型自然也重载了 和!运算符下面就可以判断是否相等了 Rust中HashMap的key要求实现Eq也就是要能完全相等而浮点数由于没有实现Eq因此不能用于HashMap的key
二、Ord / PartialOrd
大小关系也有两种一种是全序关系一种是偏序关系。 全序关系有以下性质
完整的不对称性total antisymmetrya ba ba b这三种结果只有一个是真
可传递性transitive如果a b且b c那么a c偏序关系有以下性质
不对称性antisymmetry如果a b那么 !(a b)
可传递性transitive如果a b且b c那么a c还是因为特殊值NaNNaN 0 false并且NaN 0 false并且(NaN 0) false
一PartialOrd
偏序关系
PartialOrd继承了PartialEq并且新定义了几个方法
pub trait PartialOrdRhs: ?Sized Self: PartialEqRhs {fn partial_cmp(self, other: Rhs) - OptionOrdering;fn lt(self, other: Rhs) - bool {matches!(self.partial_cmp(other), Some(Less))}fn le(self, other: Rhs) - bool {matches!(self.partial_cmp(other), Some(Less | Equal))}fn gt(self, other: Rhs) - bool {matches!(self.partial_cmp(other), Some(Greater))}fn ge(self, other: Rhs) - bool {matches!(self.partial_cmp(other), Some(Greater | Equal))}
}partial_cmp需要使用者重载返回两值的比较结果 ltlegtge默认定义好了
标准库里的所有基本类型都已实现该Trait
1.为自定义类型实现PartialOrd 要实现PartialOrd必须同时实现PartialEq
可使用#[derive(PartialOrd)]的方法实现该Trait也可手动实现
impl PartialOrd for Person {fn partial_cmp(selfotherSelf) - Optionstd::cmp::Ordering {self.height.partial_cmp(other.height)}
}实现PartialOrd只需要实现partial_cmp方法即可lt()le()gt() ge() 使用默认的
比较结果为Ordering枚举类型
pub enum Ordering {Less -1,Equal 0,Greater 1,
}为什么partial_cmp这个方法返回值类型是个Option 而非直接是一个Ordering值类型 这仍然与浮点数类型有关 因为NaN不是一个可以表示的数值 诸如3.0 NaN这样的表达式毫无意义对于这种情况partial_cmp就会返回None。 partial_cmp返回一个Option导致一个结果当结果为None时 无法决定两个值的排序即x和y会处于不确定排序。只实现PartialOrd还不足以使你的自定义类型可排序你还需要实现Ord。
实现了PartialOrd的类型会自动重载 、、 、 运算符下面就可以比较了 例子
fn main() {let p1 Person {id: 0,name: John.to_string(),height: 1.2,};let p2 Person {id: 0,name: Jack.to_string(),height: 1.4,};println!(p1 p2 {}, p1 p2);println!(p1 p2 {}, p1 p2);println!(p1 p2 {}, p1 p2);println!(p1 p2 {}, p1 p2);let x: f64 std::f64::NAN;let y 1.0f64;assert_eq!(x.partial_cmp(y), None);
}2.比较不同类型
二Ord
全序关系 Ord继承了PartialOrd和Eq并且新定义了几个方法
pub trait Ord: Eq PartialOrdSelf {fn cmp(self, other: Self) - Ordering;fn max(self, other: Self) - Self{...}fn min(self, other: Self) - Self{...}fn clamp(self, min: Self, max: Self) - Self{...}
}cmp需要使用者重载本方法返回两值的比较结果 maxminclamp已经定义好了
在标准库中只有f32和f64没有实现Ord
1.为自定义类型实现Ord 要实现Ord必须要同时实现PartialOrd和Eq。实现PartialEqPartialOrd以及Ord时要特别注意彼此之间不能冲突 例子 vector中的sort方法要求类型实现了Ord
use std::cmp::Ordering;
#[derive(DebugEq)]
pub struct Person {pub id: u32,pub name: String,pub height: f64,
}
impl PartialEqSelf for Person {fn eq(self, other: Self) - bool { self.id other.id }
}
impl PartialOrd for Person {fn partial_cmp(self, other: Self) - OptionOrdering {self.id.partial_cmp(other.id)}
}
impl Ord for Person {fn cmp(self, other: Self) - Ordering {self.id.cmp(other.id)}
}实现Ord只需要实现cmp方法即可max() 和min()使用默认的。
例子
enum BookFormat3 {Paperback,Hardback,Ebook,
}struct Book3 {name: String,format: BookFormat3,
}// -- 先实现 PartialEq
impl PartialEq for Book3 {fn eq(self, other: Book3) - bool {self.name other.name// 这里假设format字段不要求比较}
}// -- 再实现 Eq
impl Eq for Book3 {}// -- 再实现 Ord
impl Ord for Book3 {fn cmp(self, other: Book3) - Ordering {// 直接调用name(String)的cmp方法当需要实现Ord时成员字段一般都实现了Ord可直接调用其cmp方法self.name.cmp(other.name)}
}// -- 最后实现 PartialOrd
impl PartialOrd for Book3 {fn partial_cmp(self, other: Book3) - OptionOrdering {// 直接调用上面实现的cmp方法Some(self.cmp(other))}
}实现Ord的时候需要同时实现PartialOrdPartialOrd的partial_cmp()内部调用的是Ord的cmp()理由是既然一开始就想要为类型实现Ord说明类型是能够得出一个肯定结果的非None
实现了Ord之后会自动重载 、、 、 运算符下面就可以比较了 例子
use std::cmp::Ordering;
let x 1;
let y 2;
assert_eq!(x.cmp(y), Ordering::Less);
assert_eq!(y.cmp(x), Ordering::Greater);
assert_eq!(x.cmp(x), Ordering::Equal);
assert_eq!((-3).clamp(-2, 1), -2);
assert_eq!(0.clamp(-2, 1), 0);
assert_eq!(2.clamp(-2, 1), 1);
assert_eq!(1.min(2), 1);
assert_eq!(2.min(2), 2);
assert_eq!(1.max(2), 2);
assert_eq!(2.max(2), 2);例子
fn main() {let mut v vec![Person {id: 3,name: .to_string(),height: 3.0,},Person {id: 2,name: .to_string(),height: 4.0,},Person {id: 1,name: .to_string(),height: 5.0,},];v.sort();println!({:?}, v);
}2.比较不同类型
三、关于效率
你也许好奇到底是自己手动实现的效率高 还是auto-derive效率高这很难说不能一概而论比如如果你明确定知道一个大struct中只有少数几个成员与此比较直接相关或者说有决定性 那么你自己手动实现的版本很可能优于auto-derive版本 因为auto-derive版本通常会依次比较所有成员很可能做了无用功。换一个角度说 尽管auto-derive版本可能会依次检查比较每一个struct成员 但是因为它可以采用布尔表达式的短路原则 也许检查第一个成员就停止了因此也很有可能快于自定义实现版。但是Hash是一个例外它不允许短路原则必须所有成员依次都要哈希一次才可以不能偷懒但如果你能够只哈希1或2个简单成员而不是大量字符串成员那么您将很容易击败auto-derive默认实现。
