Overloading binary arithmetic operators in classes

---

Search other resources:

Contents

• 1. General information about overloading binary arithmetic operators +, –, *, /, //, %
• 2. An example of overloading the +, – operators. Class Point
• 3. An example of operator overloading +, –, *, /, //, % for the Fraction class
• Related topics

---

1. General information about overloading binary arithmetic operators +, –, *, /, //, %

Binary arithmetic operators in classes take 2 operands. The general form of calling a binary arithmetic operator is:

res = a op b

where

• a, b – operands on which the operation is performed;
• op – one of the operations +, –, *, /, //, %;
• res – the resulting object.

To overload the corresponding binary operator in a class, you must implement the corresponding method.

Below is a list of common methods for overloading binary operators +, -, *, /, //, %, operating on objects:

• __add__() – overload of the binary operator + (addition). The method is called in an expression like a+b;
• __sub__() – binary operator overloading – (subtraction). The method is called when objects a-b are subtracted;
• __mul__() – binary operator overload * (multiplication). The method is called when the two operands a*b are multiplied;
• __div__() – overload of the binary operator / (division). Called in expressions like a/b;
• __mod__() – overload of binary operator % (remainder from division). Called in expression a%b;
• __floordiv__() – binary operator overload // (divide with rounding down). Called in the expression a//b.

  ⇑

2. An example of overloading the +, – operators. Class Point

The example declares the Point class, which implements a point on the coordinate plane. The class overloads the + (addition) and – (subtraction) operators. To do this, the __add__() and __sub__() methods are declared in the class.

# Overloading the binary operator +

# A class that describes a point on a coordinate plane
class Point:

    # Class constructor
    def __init__(self, x, y):
        self.x = x
        self.y = y
        return

    # Methods for accessing the fields self.x, self.y
    def GetX(): return self.x
    def GetY(): return self.y
    def SetXY(self, x, y):
        self.x = x
        self.y = y
        return

    #-------------- Operator overloading methods --------------
    # Binary operator overload + (object summation) - __add__() method
    def __add__(self, pt):
        obj = Point(self.x + pt.x, self.y + pt.y)
        return obj

    # Binary subtraction operator overload - __sub__() method
    def __sub__(self, pt):
        # coordinate subtraction
        obj = Point(self.x - pt.x, self.y - pt.y)
        return obj

    # ---------------------------------------------------------
    # Method that prints the values of internal x, y coordinates
    def Print(self, msg):
        print(msg, " => x = ", self.x, "; y = ", self.y)
        return

# Testing
pt1 = Point(1,3)
pt1.Print("pt1")

pt2 = Point(2,6)
pt2.Print("pt2")

pt3 = pt1 + pt2
pt3.Print("pt1 + pt2")

(pt1-pt2).Print("pt1 - pt2")

Result

pt1 => x = 1, y = 3
pt2 => x = 2, y = 6
pt1 + pt2 => x = 3, y = 9
pt1 - pt2 => x = -1, y = -3

  ⇑

3. An example of operator overloading +, –, *, /, //, % for the Fraction class

The example declares the class Fraction in which the standard binary arithmetic operators are overloaded.

For operators +, –, *, /, the corresponding operations of addition, subtraction, multiplication, division of two fractions are performed. The // (integer division) operator returns a fractional number from the division of the operands. The % (remainder) operator returns an integer from the division of the operands.

The class contains the Normal() method, which normalizes the fraction

-8/-12 = 2/3

The text of the program is as follows

# Overloading the binary operator +

# The class that describes the fraction
class Fraction:

    # Class constructor, num - numerator, denom - denominator
    def __init__(self, num, denom):
        self.num = num
        self.denom = denom

        # Correction num, denom
        if self.num == 0: self.num = 1
        if self.denom == 0: self.denom = 1

        self.Normal()
        return

    # Methods for accessing the fields self.num, self.denom
    def GetNum(): return self.num
    def GetDenom(): return self.denom
    def Set(self, num, denom):
        self.num = num
        self.denom = denom
        return

    #-------------- Operators overloading methods --------------
    # Overloading of the binary operator + (fraction summation) - the __add__() method
    def __add__(self, frac):
        obj = Fraction((self.num*frac.denom+self.denom*frac.num), self.denom*frac.denom)
        return obj

    # Overloading the binary subtraction operator - __sub__() method
    def __sub__(self, frac):
        # subtract fractions
        obj = Fraction((self.num*frac.denom-self.denom*frac.num), self.denom*frac.denom)
        return obj

    # Overloading binary * (multiply) - __mul__() method
    def __mul__(self, frac):
        obj = Fraction(self.num*frac.num, self.denom*frac.denom)
        return obj

    # Overloading binary / (division) - метод __div__()
    def __div__(self, frac):
        obj = Fraction(self.num*frac.denom, self.denom*frac.num)
        return obj

    # Overloading binary // (integer division) - метод __floordiv__()
    def __floordiv__(self, frac):
        # The method returns the result of division of type float
        return float((self.num*frac.denom) / (self.denom*frac.num))

    # Overloading the binary operator % (taking the remainder) - the __mod__() method
    def __mod__(self, frac):
        # The method returns the result of division of type int
        return int((self.num*frac.denom) / (self.denom*frac.num))

    # ---------------------------------------------------------
    # Method that outputs the value of internal x, y coordinates
    def Print(self, msg):
        print(msg, " => ", self.num, " / ", self.denom)
        return

    # Method that normalizes the fraction 8/12 => 2/3
    def Normal(self):
        t = abs(self.num)
        i = 1
        num = i
        while i <= t:
            if ((self.num%i) == 0) and ((self.denom%i) == 0):
                num = i
            i = i+1

        self.num = self.num / num
        self.denom = self.denom / num

        # (-num)/(-denom) => num/denom
        if (self.num<0) and (self.denom<0):
            self.num = -self.num
            self.denom = -self.denom
        return

# Testing
f1 = Fraction(6, -12)
f1.Print("f1")
f2 = Fraction(2, -12)
f2.Print("f2")

f3 = f1 + f2
f3.Print("f1 + f2")

f3 = f1 - f2
f3.Print("f1 - f2")

f3 = f1 * f2
f3.Print("f1 * f2")

f3 = f1 / f2
f3.Print("f1 / f2")

res = f1 // f2
print("f1 // f2 => ", res) # res = 3.0

res = f1 % f2
print("f1 % f2 => ", res) # res = 3

Result

f1 => 1 / -2
f2 => 1 / -6)
f1 + f2 => -2 / 3
f1 - f2 => -1 / 3
f1 * f2 => 1 / 12
f1 / f2 => 3 / 1)
f1 // f2 => 3.0
f1 % f2 => 3

  ⇑

---

Related topics

• Overloading operators in classes. General information. Operators overloading methods. Examples
• Accessing elements by index. Methods __getitem__() and __setitem()__
• Overloading the shortened assignment operators +=, -=, *=, /=, //=, %=

  ⇑

---