[rust note] 10 operator overloading

10 - operators overloading

• operators overloading ： Let the type you define support arithmetic and other operations .

• Special types that support operator overloading ：

  Category	Special type	The operator
  Unary operators	std::ops::Neg std::ops::Not	-x !x
  arithmetic operator	std::ops::Add std::ops::Sub std::ops::Mul std::ops::Div std::ops::Rem	x + y x - y x * y x / y x % y
  Bit operators	std::ops::BitAnd std::ops::BitOr std::ops::BitXor std::ops::Shl std::ops::Shr	x & y x - y x * y x / y x % y
  Compound assignment arithmetic operator	std::ops::AddAssign std::ops::SubAssign std::ops::MulAssign std::ops::DivAssign std::ops::RemAssign	x += y x -= y x *= y x /= y x %= y
  Compound assignment bitwise operator	std::ops::BitAndAssign std::ops::BitOrAssign std::ops::BitXorAssing std::ops::ShlAssign std::ops::ShrAssign	x &= y `x
  Compare	std::cmp::PartialEq std::cmp::PartialOrd	x == y、x != y x < y、x <= y、x > y、x >= y
  Indexes	std::ops::Index std::ops::IndexMut	x[y]、&x[y] x[y] = z、&mut x[y]

10.1 - Arithmetic and bitwise operators

10.1.1 - Unary operators

• * Reference operator

• std::ops::Neg Special type ： Implement the unary negation operator -.

  trait Neg {
        
    type Output;
    fn neg(self) -> Self::Output;
  }
  

• std::ops::Not Special type ： Implement unary non operator !.

  trait Not {
        
    type Output;
    fn not(self) -> Self::Output;
  }
  

• Generic implementation of negation of complex values ：

  use std::ops::Neg;
  
  impl<T, O> Neg for Complex<T> where T: Neg<Output=O> {
        
    type Output = Complex<O>;
  
    fn neg(self) -> Complex<O> {
        
      Complex {
        
        re: -self.re;
        im: -self.im
      }
    }
  }
  

10.1.2 - Binary operators

• Rust All numeric types of implement arithmetic operators ;

• Rust And bool Implements the bitwise operator .

• They also implement logic that accepts references to these types as one or two operands .

• The special types of arithmetic operators and bit operators have unified forms ：

  //  in the light of ^ Operator std::ops::BitXor The definition of 
  trait BitXor<RHS=Self> {
        
    type Output;
    fn bitxor(self, rhs: RHS) -> Self::Output;
  }
  

• Use + Operators can put a String And a &st Slice or another String Splice up . however Rust Don't allow + The left operand of is &str, The purpose is to prevent the construction of long strings by repeating small left operands .（ Will cause performance hazards ： The time required is positively related to the square of the final string length ）

• You need to splice strings one by one , Best use write!.

10.1.3 - The compound assignment operator

• Rust All numeric types of implement arithmetic compound assignment operators ;

• Rust And bool It also implements the bit compound assignment operator .

• Yes Complex Type to proceed AddAssign The generic implementation of ：

  use std::ops::AddAssign;
  
  impl<T> AddAssign for Complex<T> where T: AddAssign<T> {
        
    fn add_assign(&mut self, rhs: Complex<T>) {
        
      self.re += rhs.re;
      self.im += rhs.im;
    }
  }
  

• The built-in features of the compound operator and the corresponding binary operator are independent of each other .

• Realization std::ops::Add It doesn't work automatically std::ops::AddAssign. If you want a custom type to act as += The left operand of the operator , Then it must be realized AddAssign.

• And binary type Shl and Shr similar ,ShlAssign and ShrAssign Special type ： No will RHS The type parameter defaults to Self, Therefore, the type of right operand must be clearly given in the implementation .

10.2 - Equality test

• == and != It's a call to std::cmp::PartialEq Special method eq and ne Abbreviation ：

  assert_eq!(x == y, x.eq(&y));
  assert_eq!(x != y, x.ne(&y));
  

• std::cmp::PartialEq The definition of ：

  trait PartialEq<Rhs: ?Sized = Self> {
        
    fn eq(&self, other: &Rhs) -> bool;
    fn ne(&self, other: &Rhs) -> bool {
        
      !self.eq(other)
    }
  }
  

• Complex Full implementation ：

  impl<T: PartialEq> PartialEq for Complex<T> {
        
    fn eq(&self, other: &Complex<T>) -> bool {
        
      self.re == other.re && self.im == other.im
    }
  }
  

• Rhs: ?Sized Relaxed Rust There must be size restrictions on type parameters , To support the PartialEq<str> or PartialEq<T> Such a special type . Method eq and ne receive &Rhs Parameters of type , You can compare &str and &[T].

• The standard library will Eq Defined as PartialEq An extension of , And there is no new method defined ：

  trait Eq: PartialEq<Self> {
         }
  

  • by Complex Type implementation Eq:

    impl<T: Eq> Eq for Complex<T> {
             }
    

  • stay Complex Type defined derive Property contains Eq It can also be realized ：

    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
    struct Complex<T> {
            
      ...
    }
    

10.3 - Sequence comparison

Rust Pass the special type std::cmp::PartialOrd Specifies the sequential comparison operator <、>、<= and >= act ：

trait PartialOrd<Rhs = Self>: PartialEq<Rhs> where Rhs: ?Sized {
    
  fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;
  fn lt(&self, other: &Rhs) -> bool {
     ... }
  fn le(&self, other: &Rhs) -> bool {
     ... }
  fn gt(&self, other: &Rhs) -> bool {
     ... }
  fn ge(&self, other: &Rhs) -> bool {
     ... }
}

10.4-Index And IndexMut

• By implementing std::ops::Index and std::ops::IndexMut Special type , You can use something like a[i] Such an index expression .

  trait Index<Idx> {
        
    type Output: ?Sized;
    fn index(&self, index: Idx) -> &Self::Output;
  }
  
  trait IndexMut<Idx>: Index<Idx> {
        
    fn index_mut(&mut self, index: Idx) -> &mut Self::Output;
  }
  

• a[i..j] Is the abbreviation of the following expression ：

  *a.index(std::ops::Range {
         start: i, end: j })
  

10.5 - Other operators

*val Dereference operators and . Call the point operator of the method , have access to Deref and DerefMut Special type to overload .

The following operators do not support overloading ：

• Error checking operator ? It can only be used for Result value ;
• Logical operators && and || Boolean values only ;
• .. Operators can only be used to create Range value ;
• & Operators can only borrow references ;
• = Operators can only transfer or copy values .
• f(x) Function call operators do not support overloading , If you want a callable value , Usually write a closure .

---

See 《Rust Programming 》（ Jim - Brandy 、 Jason, - By orendov , Translated by lisongfeng ） Chapter 12
Original address