Ruby Q & A


How to define operator overloading in Ruby?

In Ruby, operator overloading allows you to define custom behaviors for operators like `+`, `-`, `*`, `/`, `==`, and many others when used with instances of your own classes. This enables you to make your objects work with operators in a way that makes sense for your specific use case. Operator overloading is achieved by defining specific methods within your class that correspond to the desired operator.

To define operator overloading in Ruby, you need to implement special methods with specific names for each operator. For example, to overload the `+` operator for a custom class, you should define a method called `+` within that class. Here’s an example:


class MyVector

  attr_accessor :x, :y

  def initialize(x, y)

    @x = x

    @y = y


  # Overload the + operator

  def +(other) + other.x, @y + other.y)


  # Overload the == operator

  def ==(other)

    @x == other.x && @y == other.y



# Create two instances of MyVector

vector1 =, 2)

vector2 =, 4)

# Use the overloaded + operator

result = vector1 + vector2

puts "Result: (#{result.x}, #{result.y})" # Output: Result: (4, 6)

# Use the overloaded == operator

puts vector1 == vector2 # Output: false


In the code above, we’ve defined the `+` and `==` methods to overload the `+` and `==` operators for the `MyVector` class. When you use these operators with instances of `MyVector`, Ruby calls the corresponding methods, allowing you to define custom behavior for these operators.

By defining operator overloading, you can make your classes more expressive and user-friendly, as they can mimic the behavior of built-in Ruby types. However, it’s essential to adhere to Ruby’s conventions and document your custom operator behaviors for clarity and maintainability in your code.

Previously at
Flag Argentina
time icon
Experienced software professional with a strong focus on Ruby. Over 10 years in software development, including B2B SaaS platforms and geolocation-based apps.