C++ Operator Overloading

Operators for your types

Built-in types already know + and <<. int adds.ostream prints. A type you wrote does not, until you say how. Operator overloading is that definition: a function named operator+ or operator<< that the compiler calls when it sees the symbol.

Use it when the symbol already has a clear meaning. Adding two points should move by both offsets. Printing a point should show both coordinates. Do not invent a private language of operators.

Add two points

A Point holds x and y. operator+ as a member takes the other point, builds a third, and returns it. The left operand is this object. The right operand is the parameter. Neither original point changes.

#include <iostream>
using namespace std;

struct Point {
  int x;
  int y;
  Point operator+(Point other) {
    Point sum;
    sum.x = x + other.x;
    sum.y = y + other.y;
    return sum;
  }
};

int main() {
  Point a;
  a.x = 2;
  a.y = 3;
  Point b;
  b.x = 4;
  b.y = 1;
  Point c = a + b;
  cout << c.x << " " << c.y << endl;
  return 0;
}

Output is 6 4. The line Point c = a + b; is the call a.operator+(b).

The result is a Point

Because + returns a Point, you can add again. a + b + d first buildsa + b, then adds d to that temporary. Each step is the same function.

#include <iostream>
using namespace std;

struct Point {
  int x;
  int y;
  Point operator+(Point other) {
    Point sum;
    sum.x = x + other.x;
    sum.y = y + other.y;
    return sum;
  }
};

int main() {
  Point a;
  a.x = 1;
  a.y = 0;
  Point b;
  b.x = 2;
  b.y = 5;
  Point d;
  d.x = 3;
  d.y = -1;
  Point total = a + b + d;
  cout << total.x << " " << total.y << endl;
  return 0;
}

Output is 6 4 again. If you need to change a point in place, write a named function such asmove_by. Keep + for a new value, the same way 2 + 3 does not rewrite2.

Print with operator<<

cout << n works because << is overloaded for integers. ForPoint, define a free function named operator<<. The left side is the stream. The right side is the point. Return the stream so << endl still chains.

Fields on this struct are public, so the function does not need friend. It readsp.x and p.y the same way main would.

#include <iostream>
using namespace std;

struct Point {
  int x;
  int y;
};

ostream& operator<<(ostream& out, Point p) {
  out << "(" << p.x << ", " << p.y << ")";
  return out;
}

int main() {
  Point p;
  p.x = 8;
  p.y = -2;
  cout << p << endl;
  return 0;
}

Output is (8, -2). The compiler rewrites cout << p as operator<<(cout, p).

Add and print together

Once both operators exist, an expression looks like ordinary math followed by an ordinary print. That is the point of the feature: the call is still a function, but the line reads as the idea.

#include <iostream>
using namespace std;

struct Point {
  int x;
  int y;
  Point operator+(Point other) {
    Point sum;
    sum.x = x + other.x;
    sum.y = y + other.y;
    return sum;
  }
};

ostream& operator<<(ostream& out, Point p) {
  out << "(" << p.x << ", " << p.y << ")";
  return out;
}

int main() {
  Point start;
  start.x = 0;
  start.y = 0;
  Point step;
  step.x = 3;
  step.y = 4;
  cout << start << endl;
  cout << start + step << endl;
  return 0;
}

First line (0, 0). Second line (3, 4). start is still the origin.

Keep the meaning of the symbol

Overload an operator only when a reader already knows what it should do. + for a sum or a combined offset is fair. + that writes a file is not. The compiler will accept a surprising body. Other people will not.

You cannot invent a brand-new symbol. You can only teach an existing operator a new type. Precedence stays the same as for int: you do not get to make + bind tighter than *.

What to write next

Function overloading (same name, different parameters) and operator overloading (same symbol, your type) are cousins. Templates go further: one function body, many types, without listing each overload by hand. That is the next chapter.