Document

Operator Overloading

Introduction

Operator overloading is when we rewrite the function of an operator.

For example, we expect the binary + operator to add the left and right inputs and return the result. If it was a function, we may see it as operator+(left_value, right_value). Depending on the data types of the left_value and right_value variables, the compiler will know which version of the + operator to call (remember function overloading).

So what will the compiler call when we want to use the + operator with user-defined types (in our case, classes)? It will be an error because no such overload exists! That's when operator overloading comes in.

// MyInt is a user-defined class
MyInt c1 { 3 };
MyInt c2 { 4 };

/*
  This will NOT be 7.
  We are adding two objects,
  not two ints.
 */
std::cout << c1 + c2;

/*
  Same as above.
  Using anonymous classes
  to make it more obvious
 */
std::cout << 
  MyInt{ 3 } <<
  MyInt{ 4 };



/*
  This DOES work
  because we are adding
  two integers.
 */
std::cout << 
  c1.getInt() + c2.getInt();

/*
  Anonymous class style.
  Does work
 */
std::cout << 
 MyInt{ 3 }.getInt() <<
 MyInt{ 4 }.getInt();

Limits

You can overload almost every existing (you can't create your own) operator, except for: conditional (?:), member selector (.), member pointer selector (.*), scope resolution (::), typeid, casting operators, and sizeof.

You can only overload operators that work with at least one user-defined type. You can't overload the plus operator and expect the plus operator to use the overloaded function on two ints (the compiler will call the appropriate type in this case, we don't have control over this).

The arity level (number of operands) remains the same. Unary operators will only work with one operand, binary two, and ternary with three (though you can't overload the only ternary operator in C++).

Precedence and associativity of the operator still keep their default level, regardless of the new functionality!

Not a limit, but it's also best to keep the new overloaded function as close to the original function of the operator. binary + means add two things, binary - means subtract, etc.

Overloading Operators

Writing an operator-overload function is pretty simple, just looks intimidating for beginners.

Operator-overload functions can either be members or normal free functions (outside the class). Free functions are preferred since they partake in implicit conversions (member functions won't guarantee implicit conversion, but it should work most of the time); that's less typing for the programmer! There are also cases where free-functions just won't cut it which we'll see later in this chapter.

The syntax is [return type] operator[operator e.g. + - * etc.](<parameters if any>){ code-block }.

It was convention to name the parameters (identifiers) for binary operators as "left" and "right" or "l" and "r" or similar, but I don't see that anymore. Forgotten or because evaluation is random? I don't know, just my guess.

class MyInt {
  private:
    int m_myint{};

  public:
    MyInt(int i{0}) :
      m_myint{ i } {}
    
    int getInt() const {
      return m_myint;
    }
};

/*
  Overloaded free function.
  Note it must be in the 
  same name space as the class.

  This is a normal function.
  Returns a type MyInt, but 
  the name must be operator+,
  we can not name this whatever
  we want, that is the only
  difference.

  Parameters are references
  for performance reasons.
  const because I don't 
  plan to change anything.

  I don't use the conventional
  "left" and "right" identifier
  names.
 */
MyInt operator+(const MyInt& m1, const MyInt& m2) {
  // Returns a newly created MyInt.
  return MyInt{ m1.getInt() + m2.getInt() };
}


// Usage
MyInt m1{ 9 };
MyInt m2{ 3 };
MyInt m3{ m1 + m2 };
MyInt m4{ m1 + 7 }; // LEGAL does implicit conversion.
MyInt m5{ 7 + m2 }; // LEGAL does implicit conversion.
MyInt m6{ 7 + 12 }; // LEGAL does implicit conversion.

std::cout << m3.getInt(); // 12
std::cout << m4.getInt(); // 16
std::cout << m5.getInt(); // 10
std::cout << m6.getInt(); // 19


// ILLEGAL
std::cout << m1 + m2; // ERROR no operator << for type MyInt

/*
  Since the operator <<
  has no overload for type
  MyInt, the compiler throws
  an error at the above.

  HOMEWORK:
  You can fix this by
  just returning an int
  instead. 
 */

If you want to see the member operator overloaded function.

class MyInt {
  private:
    int m_myint{};

  public:
    MyInt(int i{0}) :
      m_myint{ i } {}

    // Only one parameter needed (right-hand)
    MyInt operator+(const MyInt& m2);
    
    int getInt() const {
      return m_myint;
    }
};

/*
  Use the scope resolution
  for outside class definition.
 */
MyInt MyInt::operator+(const MyInt& m2) {
  /*
    Since this function is
    a member, it has access
    to its privates.
   */
  return MyInt{ m_myInt + m2.getInt() };
}

MyInt m1{ 2 };
MyInt m2{ 3 };
MyInt m3{ m1 + m2 };

/*
  These two SHOULD work
  because of implicit conversion,
  but it's not guaranteed.

  I personally had no trouble
  with this so maybe it's 
  false that "there is no 
  guarantee!"
 */
MyInt m4{ m3 + 5 };
MyInt m4{ 7 + 5 };

Friends

I was going to cover friends in the class relations chapter (future), but it's also used for operator overloading.

Friend functions just allow a function to access private members of a class. That simple, however, the class must know if a function is a friend or not.

Multiple classes can have the same friends (be cautious of scope though, it's common to use class prototypes with friend functions of multiple classes).

Real world example, to keep it PG, let's say you have a private member which is your smart phone. You shouldn't let strangers have access to your smart phone, you never know what they're up to! So they can't have access to your private member. Friends, however, are a little more trustworthy, so it's fine if they have access to your private member.

Strangers: my privates are not for you! Friends: my privates are fine for you!

My C++ teacher taught this example to us, and it stuck so I thought it would for you too.

class MyInt {
  private:
    int m_myint{};

  public:
    MyInt(int i{0}) :
      m_myint{ i } {}
    
    int getInt() const {
      return m_myint;
    }

    // Let the class know
    // Note we don't define it in the class
    friend MyInt operator+(const& MyInt m1, const& MyInt m2);
};

MyInt operator+(const MyInt& m1, const MyInt& m2) {
  /*
    The only true benefit
    of using friend functions,
    you have access to 
    the privates.
   */
  return MyInt{ m1.my_int + m2.my_int};
}

// Works the same as the previous code example

Using friend functions for operator overloading isn't really all that beneficial over non-friend functions, and since friend functions have more access to a classes's internals, it is not recommended to use friend functions unless you absolutely have to! As always, what you use depends on your program, but more privacy for classes is usually better so that's why normal functions are preferred!

And I suppose non-friends have to make an extra function call just to get a single value so consider that too! All your choice really.

So when to use what function?

If a binary operator WONT modify the left operand, use normal or friends since it gives the benefit of implicit conversions.

If a binary operator WILL modify the left operand (e.g. assignment operators such as +=), prefer member functions since the left operand must always be a class type.

Unary operators (including subscript[], function(), assignment=, and member selection ->) are typically member functions since they don't need other parameters or "outside influence" to work.

Operators that require "fixed" parameters (we'll se the stream operators next) should be normal or friends.

Overloading IO Streams

As implied previously, you can also overload the input and output stream operators, but require a different approach.

The only difference is we'll use the type std::ostream for output and std::istream for input.

Requires <iostream>

Ostream

We use two parameters because << is a binary operator. Left-hand side is std::cout and right-hand side is what to be printed.

This is why std::cout << ("Hello" << "World"); doesn't work.

Note std::ostream must be returned by reference, since returning by value is not allowed with ostream (copies of ostream are forbidden).

#include <iostream>

class Vector3D {
  private:
    double m_x{};
    double m_y{};
    double m_z{};

  public:
    Vector3D(double x{0.0}, double y{0.0}, double z{0.0})
      : m_x{x}, m_y{y}, m_z{z} {}
    
    // Let the class know
    friend std::ostream& operator<< (std::ostream& out, const Vector3D& v);
};

std::ostream& operator<< (std::ostream& out, const Vector3D& v) {
  // Send to the out stream
  out << 
    "Location: (" << 
      v.m_x << ", " <<
      v.m_y << ", " <<
      v.m_z;

  // Return out stream
  return out;
}

// Implementation
Vector3D player{ 1.0, 3.3, 6.2 };

std::cout << player; // Location: (1.0, 3.3, 6.2)

The benefit of this is it just makes outputting class members easier and cleaner!

You can use friend or normal functions it's up to you. Friends just make it easier but the danger of exposing privates still exists.

Istream

Everything that holds true for ostream overloading holds true for istream overloading, so I wont go much into detail.

Only difference is since we do want to change our members, then that means that our right-hand operand will not be const. It'll still be a reference since it's a free-function and passing in objects is expensive.

#include <iostream>

class Vector3D {
  private:
    double m_x{};
    double m_y{};
    double m_z{};

  public:
    Vector3D(double x{0.0}, double y{0.0}, double z{0.0})
      : m_x{x}, m_y{y}, m_z{z} {}
    
    // Let the class know
    friend std::ostream& operator<< (std::ostream& out, const Vector3D& v);
    friend std::istream& operator>> (std::istream& in, Vector3D& v);
};

std::ostream& operator<< (std::ostream& out, const Vector3D& v) {
  // Send to the out stream
  out << 
    "Location: (" << 
      v.m_x << ", " <<
      v.m_y << ", " <<
      v.m_z;

  // Return out stream
  return out;
}

std::istream& operator>> (std::istream& in, Vector3D& v) {
  in >> v.m_x;
  in >> v.m_y;
  in >> v.m_z;

  // Return in stream
  return in;
}

// Implementation
Vector3D player{};

// Input Stream
std::cin >> player; // Assume input: 1.0 3.3 6.2

std::cout << player; // Location: (1.0, 3.3, 6.2)

Yup it was that easy!

Unary Operators

Unary operators are a bit more straightforward. Same as binary, but without parameters.

Since unary operators don't modify anything of the class internally, it is ideal to use const return like accessor functions.

class MyInt {
  private:
    int m_myint{};

  public:
    MyInt(int i{0}) :
      m_myint{ i } {}

    MyInt operator-() const {
      /* 
        Implicit conversion
        will return a MyInt
        since the return 
        type is expecting a 
        MyInt.

        You don't have
        to have curly braces,
        but that tells us
        it's converting versus
        -m_myint looks like
        it's returning an int.
       */
      return { -m_myint };
    }
    
    int getInt() const {
      return m_myint;
    }
};

// Usage
MyInt mine{ 12 };

/*
  (-mine) returns a MyInt 
  so we have access to 
  getInt() from that return!
 */
std::cout << (-mine).getInt();

The only "gotcha" with unary operators is the logical negation (!) operator, it must return a bool.

/*
  This is just an example
  showing to return a boolean,
  the logic can be different!
 */
bool operator!() const {
  return m_myint == 0;
}

Comparison Operators

Overloading comparison operators are the same, only difference is they return booleans.

class Vector3D {
  private:
    double m_x{};
    double m_y{};
    double m_z{};

  public:
    Vector3D(double x{0.0}, double y{0.0}, double z{0.0})
      : m_x{x}, m_y{y}, m_z{z} {}
    
    // Let the class know
    /*
      Using friend to not
      type out the accessors
      #lazyCPP
     */
    friend bool operator==(const Vector3D& v1, const Vector3D& v2);
};

bool operator==(const Vector3D& v1, const Vector3D& v2) {
  return (
    v1.m_x == v2.m_x &&
    v1.m_y == v2.m_y &&
    v1.m_z == v2.m_z 
  );
}

// Usage
Vector3D player { 1.0, 67.3, 564.433 };
Vector3D monster { 5.0, 6.3, 54.33 };

if (player == monster) {
  std::cout << "Player is hit!\n";
}

And same for the others, all boolean logic.

Tricks

You may know that a != b is just !(a == b), and we can use those tricks to make our operator overloading life easier!

These tricks may not be suitable for your program, but they're still cool to know.

And in these examples it may seem pointless and overly complicated, but when you write larger bodies, these might come in handy to prevent redundancy.

/* 
  Assume a and b are references 
  to const user-defined objects
  with int member x
 */

/*
  !=
  != is the same as !(x == y)

  is x the same as y?
  if yes, evaluate to
  true then flip to 
  false because they
  ARE equal.

  is x different from y?
  if yes, evaluate to
  false then flip to
  true because they
  ARE NOT equal.
 */
bool operator==(a, b) {
  return a.x == b.x;
}

bool operator !=(a, b) {
  return !(operator==(a,b));
}



/*
  >
  x > y is the same as 
  y < x

  4 > 1 ? yes!
  1 < 4 ? yes!

  8 > 9 ? No!
  9 < 8 ? No!

  Same results when 
  we flip everything.
 */
bool operator<(a, b) {
  return a.x < b.x;
}

bool operator>(a, b) {
  return operator<(b, a);
}



/*
  <= and >=
  <= is the same as
  !(x > y)

  5 <= 7 ? Yes!
  5 > 7  ? No!
  !(No)     ? Yes!

  6 <= 2 ? No!
  6 > 2  ? Yes!
  !(Yes)    ? No!

  >= is the same as
  !(x < y)

  Same as above, or
  try yourself!

 */
bool operator<=(a, b) {
  return !(operator>(a, b));
}

bool operator>=(a, b) {
  return !(operator<(a, b));
}

Postfix and Prefix Operators

Postfix and prefix operators also have a trick up their sleeve, but it's not a tricky one.

For one, this one is supposed to modify the class (generally its members), and how does the compiler know which overload was used? They both use the operator++ identifier.

Prefix has NO parameters and postfix takes an int. Generally, the int is anonymous meaning it doesn't have an identifier therefore it's never used in the body.

And prefix normally return a pointer to itself (mostly for chaining operators, that is using multiple operators in one statement, but if you don't want that then return what's right for your program).

Postfix returns its old state. Remember, postfix makes a copy, does the operation (incrememnt or decrement), then returns the copy!

class MyObj {
  private:
    int m_i{};

  public:
    MyObj(int i) : m_i{ i }
    {}

    // Prefix NO parameters
    MyObj& operator++(){
      ++m_i;

      // Return a pointer to itself.
      return *this;
    }

    // Postfix anonymous int
    // Returns a MyObj NOT a pointer
    MyObj operator++(int){
      // Make a copy to keep the old state
      MyObj temp{ *this };

      // Increment using prefix
      ++(*this);

      // Then return the copy
      return temp;
    }

    // For output
    friend std::ostream& operator<< (std::ostream& out, const MyObj& o);
};
std::ostream& operator<< (std::ostream& out, const MyObj& o) {
  out << o.m_i;
  return out;
}


// Usage
MyObj o{ 2 };

std::cout << o++; // 2
std::cout << ++o; // 4
std::cout << o;   // 4

Now you see why postfix is less efficient!

Assignment Operator

The assignment operator is also a bit complicated, but similar to the prefix operator.

/*
  Same MyObj class as above.

  Note that the parameter is of
  the right-hand operand. It
  will not be changed
  so we const it.
 */
MyObj& operator=(const MyObj& o) {
  // Check if we're self assigning
  if (this == &o)
    return *this;

  // Otherwise overwrite new data
  m_i = o.m_i;

  return *this;
}

We just have to watch out for self-assignment. Self-assignment with objects can lead to garbage. Though we're not doing it here, it's best to make the check second nature!

ADVANCED: why not just use copy constructors? Assignment allows for assignment anywhere versus copy constructors are only used during initialization.

We'll see copy constructors in the next chapter!

C++ Tutorial | 13.2 Classes - Operator Overloading