Rust FAQ: Operator Overloading

PART05 -- Operator Overloading

Q21: What is operator overloading in Rust?

Operator overloading in Rust lets you define custom behavior for operators like +, -, *, or == when they’re used with your own types (like structs or enums). Instead of the operator doing its usual job (like adding numbers), you can tell Rust what it should do for your type. This makes your code more intuitive and lets your types work like built-in ones.

Rust uses traits from the std::ops module to overload operators. For example, to make + work for your type, you implement the Add trait. Here’s an example with a Point struct:

use std::ops::Add;

struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Point; // The result type of the addition
    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 3, y: 4 };
    let p3 = p1 + p2; // Uses custom + behavior
    println!("Result: ({}, {})", p3.x, p3.y); // Prints (4, 6)
}

Why use it?

• Makes your types feel natural to use (e.g., point1 + point2 reads better than point1.add(point2)).
• Lets you define meaningful operations, like adding two vectors or comparing custom objects.
• Keeps code clean and expressive while staying safe, thanks to Rust’s strict rules.

Q22: What operators can/cannot be overloaded?

In Rust, you can overload many operators, but not all, and it’s done by implementing specific traits from the std::ops module. Here’s the breakdown:

Operators You Can Overload:

• Arithmetic: + (Add), - (Sub), * (Mul), / (Div), % (Rem) for addition, subtraction, multiplication, division, and remainder.
• Bitwise: & (BitAnd), | (BitOr), ^ (BitXor), << (Shl), >> (Shr) for bitwise operations.
• Comparison: == and != (PartialEq), <, >, <=, >= (PartialOrd or Ord).
• Indexing: [] (Index for reading, IndexMut for writing).
• Unary: - (Neg) for negation, ! (Not) for logical or bitwise not.
• Assignment Variants: += (AddAssign), -= (SubAssign), *=, /=, %=, &=, |=, ^=, <<=, >>= (e.g., AddAssign for +=).
• Deref: * (Deref and DerefMut) for dereferencing pointers like Box or Rc.

Operators You Cannot Overload:

• Logical Operators: && (and), || (or) cannot be overloaded because Rust uses short-circuit evaluation, which doesn’t fit the trait system.
• Equality for References: You can’t redefine == for references (e.g., &T == &T), as Rust controls how references compare.
• Custom Operators: You can’t create new operators (like **) from scratch; you’re limited to what Rust’s traits support.
• Dot Operator (.): The . for method calls or field access isn’t overloadable.

Example: To overload == for a Point struct:

use std::cmp::PartialEq;

struct Point {
    x: i32,
    y: i32,
}

impl PartialEq for Point {
    fn eq(&self, other: &Point) -> bool {
        self.x == other.x && self.y == other.y
    }
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 1, y: 2 };
    println!("Equal: {}", p1 == p2); // Prints true
}

Rust’s trait system ensures overloading is safe and explicit, but you’re limited to the operators defined in std::ops.

Q23: Can I create a ** operator for to-the-power-of operations?

No, Rust does not allow creating a ** operator for “to-the-power-of” operations (or any new operator) because you can only overload operators that Rust already supports through its std::ops traits, and there’s no trait for **. However, you can achieve the same functionality by defining a custom method or using existing Rust features.

For example, you can create a method to handle exponentiation:

struct Number {
    value: f64,
}

impl Number {
    fn pow(&self, exponent: f64) -> Number {
        Number {
            value: self.value.powf(exponent),
        }
    }
}

fn main() {
    let n = Number { value: 2.0 };
    let result = n.pow(3.0); // 2^3 = 8
    println!("Result: {}", result.value); // Prints 8
}

Alternatively, for built-in types like f64 or i32, Rust’s standard library already provides power functions:

• f64::powf for floating-point numbers (e.g., 2.0.powf(3.0) for 2³).
• i32::pow for integers (e.g., 2.pow(3) for 2³).

Why no **?

• Rust’s design prioritizes explicitness and safety, so it limits operator overloading to a predefined set to avoid confusion or ambiguity.
• You can use methods (like pow) or functions to get the same effect, keeping your code clear.

If you really want an operator-like syntax, you could use a macro for readability, but it’s not true operator overloading:

macro_rules! pow {
    ($base:expr, $exp:expr) => {
        $base.pow($exp)
    };
}

fn main() {
    let result = pow!(2, 3); // 2^3 = 8
    println!("Result: {}", result); // Prints 8
}

This gives a similar feel but stays within Rust’s rules.