rust重载比较运算符

要重载比较运算符，需要为类型实现对应的trait。

重载==和!=，需要实现PartialEq或者Eq

重载<、<=、> 、 >=，需要实现PartialOrd或者Ord

一、Eq/PartialEq

为什么有两个trait呢？

因为相等关系有两种：一种是完全相等关系，一种是部分相等关系。

完全相等关系满足如下三个性质：

自反性：自己一定等于自己，即a=a；

对称性：若有a=b，则有b=a；

传递性：若有a=b和b=c，则有a=c；

部分相等关系只满足两个性质：

对称性：若有a=b，则有b=a；

传递性：若有a=b和b=c，则有a=c；

在浮点数类型中有个特殊的值是NaN（Not-a-number），这个值与任何值都不等，包括自己NaN != NaN，它就违背了自反性。所以判断浮点数是否相等就只能使用部分相等关系。

部分相等是全相等关系的子集，也就是说，如果两个元素具有全相等关系，那它们之间也一定有部分相等关系。

（一）PartialEq

是部分相等关系。

这个Trait中定义了两个方法：

pub Trait PartialEq<Rhs: ?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传入不同的类型，就能比较不同类型的相等性。

示例代码如下：

rust 复制代码

#[derive(PartialEq)]
enum WheelBrand { 
	Bmw, 
	Benz, 
	Michelin, 
}
struct Car { 
	brand: WheelBrand, 
	price: i32, 
}
impl PartialEq<WheelBrand> 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和enum
     assert!(car == wheel);
     // assert!(wheel == car); // 无法反过来比较
}

代码仅实现了Car与Wheel的相等性比较，若要反过来比较，还得提供反向的实现，如下：

rust 复制代码

impl PartialEq<Car> for WheelBrand {
     fn eq(&self, other: &Car) -> bool {
     	 *self == other.brand 
     }
}

（二）Eq

就是完全相等关系

这个trait继承了PartialEq，但没有添加新的方法，这个Trait只是告诉编译器，这是个完全相等关系而非部分相等关系。

pub Trait Eq：PartialEq{}

在标准库中，只有f32和f64没有实现Eq

1.为自定义类型实现Eq

实现Eq不需要额外的代码，只需要实现PartialEq，并添加#[derive(Eq)]就可以了。

实现了Eq的类型自然也重载了 == 和!=运算符，下面就可以判断是否相等了

Rust中HashMap的key要求实现Eq，也就是要能完全相等，而浮点数由于没有实现Eq，因此不能用于HashMap的key

二、Ord / PartialOrd

大小关系也有两种：一种是全序关系，一种是偏序关系。

全序关系有以下性质：

完整的不对称性total antisymmetry：a < b，a == b，a > b这三种结果只有一个是真；
可传递性transitive：如果a < b且b < c那么a < c；

偏序关系有以下性质：

不对称性antisymmetry：如果a < b那么 !(a > b)；
可传递性transitive：如果a < b且b < c那么a < c；

还是因为特殊值NaN，NaN < 0 == false并且NaN > 0 == false并且(NaN == 0) == false

（一）PartialOrd

偏序关系

PartialOrd继承了PartialEq，并且新定义了几个方法

pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
     fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;
     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：需要使用者重载，返回两值的比较结果；

lt，le，gt，ge：默认定义好了；

标准库里的所有基本类型都已实现该Trait

1.为自定义类型实现PartialOrd

要实现PartialOrd，必须同时实现PartialEq

可使用#[derive(PartialOrd)]的方法实现该Trait，也可手动实现

impl PartialOrd for Person {
     fn partial_cmp(&self，other：&Self) -> Option<std::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 + PartialOrd<Self> {
     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：需要使用者重载本方法，返回两值的比较结果；

max，min，clamp：已经定义好了；

在标准库中，只有f32和f64没有实现Ord

1.为自定义类型实现Ord

要实现Ord，必须要同时实现PartialOrd和Eq。实现PartialEq，PartialOrd以及Ord时要特别注意彼此之间不能冲突

例子

vector中的sort方法要求类型实现了Ord

use std::cmp::Ordering;
#[derive(Debug，Eq)]
pub struct Person {
     pub id: u32,
     pub name: String,
     pub height: f64,
}
impl PartialEq<Self> for Person {
     fn eq(&self, other: &Self) -> bool { self.id == other.id }
}
impl PartialOrd for Person {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         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) -> Option<Ordering> {
        // 直接调用上面实现的cmp方法
        Some(self.cmp(&other))
    }
}

实现Ord的时候需要同时实现PartialOrd，PartialOrd的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默认实现。