Free, Unlimited Access

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Professional C++





<Excerpt>


This lesson is a quick introductory tour of operator overloading within C++.  It is not intended for those who are entirely new to programming.  Rather, the people who may find it useful include:

- those who have completed our introductory course, but want a quick review
- those who are already familiar with programming in another language, but are new to C++
- those who have used C++ in the past, but would benefit from a refresher

It summarises several lessons from our introductory course.  Those looking for more thorough explanations or additional context should consider completing _**Chapter 8**_ of that course.


</Excerpt>


<CoursePromo course="intro" />


## Operator Overloading


As we’ve seen, operators such as `+` and `*=` can act upon data types built into the C++ language, such as `int`.  However, we can make our custom types interact with these operators too.  This is referred to as _**operator overloading**_.


Operators are simply functions.  For a function to act as an operator, we need to follow a specific naming convention.


For example, imagine we have a custom type called `Vector`:


```c++
struct Vector {
  float x;
  float y;
  float z;
};
```


We wanted to give `Vector` objects the ability to be added to other Vectors using the `+` operator,  That operator would return a new `Vector`.   To implement this, we’d define a function as follows:


```c++
Vector operator+(const Vector& a,
                 const Vector& b){
  return Vector{
    a.x + b.x, a.y + b.y, a.z + b.z};
}
```


Objects of our `Vector` type can now be added to other objects of that same type, using the binary `+` operator.  And, given our function’s return type is `Vector`, that operator would return another `Vector` object:


```c++
Vector a { 1.f, 2.f, 3.f };
Vector b { 1.f, 1.f, 1.f };

// { 2.f, 3.f, 4.f }
Vector Sum { a + b };
```


Operators can also be implemented as part of the struct or class that defines our type.  Below, we give our `Vector` objects the ability to be multiplied with a `float` using the binary `*` operator:


```c++
struct Vector {
  float x;
  float y;
  float z;

  Vector operator*(float Multiplier){
    return Vector{
      x * Multiplier,
      y * Multiplier,
      z * Multiplier
    };
  }
};
```


```c++
Vector a { 1.f, 2.f, 3.f };

// { 2.f, 4.f, 6.f }
Vector Result { a * 2.f };
```


<Ad />


## Unary and Binary Operators


Multiple operators can have the same function name.  For example, `operator-` can be a binary operation, ie, it operates on two objects.  This would normally be used to represent arithmetic subtraction (eg `VectorA - VectorB`)


But, `-` can also be a unary operator, acting upon only one object.  This would normally be used for negation (eg, `-VectorA`)


The compiler can infer whether we are overloading a unary or binary operator from the number of parameters.

- When defined outside the class, a binary operator will have two parameters. The left operand will be the first parameter; the right operand will be the second parameter.
- When defined within the class, a binary operator will have one parameter. The left operand will be the current object; the right operand will be the parameter.
- When defined outside the class, a unary operator will have one parameter. That parameter will be the operand.
- When defined within the class, a unary operator will have no parameters. The current object will be the operand.

Here are some examples:


```c++
#include <iostream>

struct Vector {
  float x;
  float y;
  float z;

  Vector operator-(){
    std::cout << "Unary - \n";
    return Vector{-x, -y, -z};
  }

  Vector operator-(const Vector& Other){
    std::cout << "Binary - \n";
    return Vector{
      x - Other.x,
      y - Other.y,
      z - Other.z
    };
  }
};

Vector operator+(const Vector& a){
  std::cout << "Unary + \n";
  return a;
}

Vector operator+(const Vector& a,
                 const Vector& b){
  std::cout << "Binary + \n";
  return Vector{
    a.x + b.x, a.y + b.y, a.z + b.z};
}

int main(){
  Vector A;
  -A;
  A - A;
  +A;
  A + A;
}
```


```c++
//<o>
Unary -
Binary -
Unary +
Binary +
```


<Ad />


## The `this` Pointer


For many operators, such as `++` and `*=`, it is expected that the operator will return a reference to the object it operated on.  This is important for allowing operators to be chained on our object, in expressions such as `(MyObject *= 2) *= 3`.


With statements like this, we want subsequent operators to act upon the original object, not a copy of it.


Our previous examples didn’t allow this.  However, within a class or struct function, the `this` keyword returns a pointer to the current object -  that is, the object that the function or operator was called upon.


Therefore, we can use this to ensure our operators return the exact same object they were used on:


```c++
#include <iostream>

struct Vector {
  float x;
  float y;
  float z;

  Vector& operator*=(float Multiplier){
    x *= Multiplier;
    y *= Multiplier;
    z *= Multiplier;
    return *this;//<h>
  }
};

int main(){
  Vector A{1.f, 1.f, 1.f};
  (A *= 2) *= 3;
  std::cout << "x component: " << A.x;
}
```


```c++
//<o>
x component: 6
```


<Ad />


## Postfix and Prefix Operators


Operators like `--` and `++` can be used either before or after their operand, and each usage has a different behavior.


For example, `++MyInteger` would increment the integer and return it.  `MyInteger++` would increment the integer but return a different integer, which has the value of our original integer before it was incremented.


For our custom types, overloading the prefix `++` works as expected:


```c++
struct Vector {
  float x;
  float y;
  float z;

  // ++MyVector (Prefix Operator)
  Vector& operator++(){//<h>
    ++x;
    ++y;
    ++z;
    return *this;
  }
};
```


Overloading the postfix operator has a slightly inelegant syntax.  To let the compiler distinguish between which function handles the prefix operator and which handles the postfix, we add an extra unused `int` parameter to the postfix handler:


```c++
#include <iostream>

struct Vector {
  float x;
  float y;
  float z;

  // ++MyVector (Prefix Operator)
  Vector& operator++(){//<h>
    std::cout << "Prefix ++ \n";
    ++x;
    ++y;
    ++z;
    return *this;
  }

  // MyVector++ (Postfix Operator)
  Vector operator++(int){//<h>
    std::cout << "Postfix ++ \n";
    Vector Original{x, y, z};
    ++x;
    ++y;
    ++z;
    return Original;
  }
};

int main(){
  Vector A;
  ++A;
  A++;
}
```


```c++
//<o>
Prefix ++
Postfix ++
```


<Ad />


## More Object Capabilities


Later in this course, we cover a range of further abilities we can add to our custom types.  This includes how we can:

- Overload the function call operator, `()` to let our custom types act like functions (_**functors**_).
- Implement _**iterators**_ to let our custom objects work like arrays and other collections, including compatibility with _**standardized algorithms**_ and native syntax such as _**range-based for loops**_.
- Set up _**user-defined conversions**_, to let our objects be implicitly or explicitly converted to other types, including built-in C++ types
- Implement _**three-way comparisons**_ and _**default comparisons**_ using a single function, thereby allowing our objects to be sorted and compared using boolean operators, such as `<=` and `!=`
- Customize _**copy and move semantics**_, for control over how our objects react to low-level operations like being passed to a function, or copied to a new variable

## Summary


Operator overloading allows you to define custom behavior for operators when used with objects of your custom types.


By overloading operators, you can make your custom types more intuitive and easier to use.  Key takeaways:

- Operators can be overloaded as member functions or non-member functions
- The number of parameters determines whether an operator is unary or binary
- The `this` pointer can be used to return a reference to the current object
- Postfix operators have a dummy `int` parameter to distinguish them from prefix operators
- Operator overloading enables custom types to support various operations and capabilities

<FAQ>


```javascript
//<m>
{
  slug: 'overloading-the-subscript-operator',
  title: 'Overloading the Subscript Operator',
  question: 'How can I overload the subscript operator `[]` for my custom type?',
}
```


To overload the subscript operator `[]` for your custom type, you need to define a member function named `operator[]`. This function should take an index parameter and return a reference to the element at that index.


Here's an example of overloading the subscript operator for a custom `Vector` class:


```c++
#include <iostream>

class Vector {
private:
  float elements[3];

public:
  float& operator[](int index) {
    return elements[index];
  }

  const float& operator[](int index) const {
    return elements[index];
  }
};

int main() {
  Vector v;
  v[0] = 1.0f;
  v[1] = 2.0f;
  v[2] = 3.0f;

  std::cout << v[1] << "\n";
}
```


```text
//<o>
2
```


In this example, we define two overloads of the `operator[]` function:

- One for non-const objects, which returns a non-const reference to the element.
- One for const objects, which returns a const reference to the element.

This allows us to use the subscript operator to access and modify elements of our `Vector` object, just like we would with a built-in array.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'overloading-the-function-call-operator',
  title: 'Overloading the Function Call Operator',
  question: 'What is the purpose of overloading the function call operator `()`?',
}
```


Overloading the function call operator `()` allows objects of your custom type to be used as if they were functions. This is useful for creating function objects, also known as functors.


Here's an example of overloading the function call operator for a custom `Multiplier` class:


```c++
#include <iostream>

class Multiplier {
private:
  int factor;

public:
  Multiplier(int f) : factor(f) {}

  int operator()(int x) const {
    return x * factor;
  }
};

int main() {
  Multiplier doubler(2);
  Multiplier tripler(3);

  std::cout << doubler(5) << "\n";
  std::cout << tripler(4) << "\n";
}
```


```text
//<o>
10
12
```


In this example, the `Multiplier` class overloads the function call operator to take an integer parameter `x` and return the result of multiplying `x` by the `factor` stored in the `Multiplier` object.


This allows us to create `Multiplier` objects that behave like functions. We can invoke the function call operator on these objects just like we would call a regular function, passing arguments within parentheses.


Overloading the function call operator is particularly useful when working with algorithms and libraries that expect function objects, such as the STL algorithms that take predicate functions.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'overloading-comparison-operators',
  title: 'Overloading Comparison Operators',
  question: 'How can I overload comparison operators like `==` and `<` for my custom type?',
}
```


To overload comparison operators like `==`, `!=`, `<`, `>`, `<=`, and `>=` for your custom type, you can define them as either member functions or non-member functions.


Here's an example of overloading the `==` and `<` operators for a custom `Player` class:


```c++
#include <iostream>
#include <string>

class Player {
private:
  std::string name;
  int score;

public:
  Player(const std::string& n, int s)
    : name(n), score(s) {}

  bool operator==(const Player& other) const {
    return score == other.score;
  }

  bool operator<(const Player& other) const {
    return score < other.score;
  }
};

int main() {
  Player p1("Alice", 100);
  Player p2("Bob", 200);

  std::cout << (p1 == p2) << "\n";
  std::cout << (p1 < p2) << "\n";
}
```


```text
//<o>
0
1
```


In this example, we define the `==` and `<` operators as member functions of the `Player` class. The `==` operator compares the scores of two `Player` objects for equality, while the `<` operator compares their scores for less than.


By overloading these operators, we can use them with `Player` objects just like we would with built-in types. This allows us to write more intuitive and readable code when comparing `Player` objects.


Note that if you overload the `==` operator, it's generally a good practice to also overload the `!=` operator. Similarly, if you overload `<`, consider overloading `>`, `<=`, and `>=` for completeness.


You can also overload these operators as non-member functions, in which case they would take two `Player` objects as parameters.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'overloading-arithmetic-assignment-operators',
  title: 'Overloading Arithmetic Assignment Operators',
  question: 'How can I overload arithmetic assignment operators like `+=` and `*=` for my custom type?',
}
```


To overload arithmetic assignment operators like `+=`, `-=`, `*=`, `/=`, and `%=` for your custom type, you need to define them as member functions that modify the object itself and return a reference to the modified object.


Here's an example of overloading the `+=` and `*=` operators for a custom `Vector` class:


```c++
#include <iostream>

class Vector {
 private:
  float x, y, z;

 public:
  Vector(float a, float b, float c)
    : x(a), y(b), z(c) {}

  Vector& operator+=(const Vector& other) {
    x += other.x;
    y += other.y;
    z += other.z;
    return *this;
  }

  Vector& operator*=(float scalar) {
    x *= scalar;
    y *= scalar;
    z *= scalar;
    return *this;
  }

  void print() const {
    std::cout << "(" << x << ", " << y
      << ", " << z << ")\n";
  }
};

int main() {
  Vector v(1.0f, 2.0f, 3.0f);
  Vector u(0.5f, 0.5f, 0.5f);

  v += u;
  v.print();

  v *= 2.0f;
  v.print();
}
```


```text
//<o>
(1.5, 2.5, 3.5)
(3, 5, 7)
```


In this example, we define the `+=` and `*=` operators as member functions of the `Vector` class. The `+=` operator adds the components of another `Vector` object to the current object, while the `*=` operator multiplies each component of the current object by a scalar value.


Both operators modify the object itself and return a reference to the modified object using `*this`. This allows for chaining multiple arithmetic assignment operations.


By overloading these operators, we can use the familiar syntax of `+=` and `*=` with our custom `Vector` objects, making the code more readable and expressive.


Remember to define the behavior of these operators according to the specific semantics of your custom type.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'overloading-the-stream-insertion-operator',
  title: 'Overloading the Stream Insertion Operator',
  question: 'How can I overload the `<<` operator to print objects of my custom type?',
}
```


To overload the `<<` operator for printing objects of your custom type, you need to define it as a non-member function that takes an `ostream` reference and a const reference to your custom type as parameters. The function should return the `ostream` reference to allow for chaining multiple insertions.


Here's an example of overloading the `<<` operator for a custom `Player` class:


```c++
#include <iostream>
#include <string>

class Player {
private:
  std::string name;
  int score;

public:
  Player(const std::string& n, int s)
    : name(n), score(s) {}

  friend std::ostream& operator<<(
    std::ostream& os, const Player& player) {
    os << "Player: " << player.name
      << ", Score: " << player.score;
    return os;
  }
};

int main() {
  Player p1("Alice", 100);
  Player p2("Bob", 200);

  std::cout << p1 << "\n";
  std::cout << p2 << "\n";
}
```


```text
//<o>
Player: Alice, Score: 100
Player: Bob, Score: 200
```


In this example, we define the `<<` operator as a non-member function that takes an `ostream` reference (`os`) and a const reference to a `Player` object. The function accesses the private members of the `Player` class, so we declare it as a friend function inside the class.


Inside the function, we use the `<<` operator to insert the desired output format into the `ostream`. We return the `ostream` reference to allow for chaining multiple insertions.


Now we can use the `<<` operator with `Player` objects just like we would with built-in types, printing them to the console or any other output stream.


By overloading the `<<` operator, we provide a convenient way to print objects of our custom type, making the code more readable and avoiding the need for explicit printing functions.


Remember to include any necessary headers (e.g., `<iostream>` for `std::ostream`) and to adjust the output format according to your specific requirements.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'overloading-operators-for-type-conversions',
  title: 'Overloading Operators for Type Conversions',
  question: 'Can I overload operators to perform type conversions for my custom type?',
}
```


Yes, you can overload operators to perform type conversions for your custom type. This allows objects of your custom type to be implicitly or explicitly converted to other types.


Here's an example of overloading the conversion operator to convert objects of a custom `Number` class to `int` and `double`:


```c++
#include <iostream>

class Number {
private:
  int value;

public:
  Number(int v) : value(v) {}

  operator int() const {
    return value;
  }

  operator double() const {
    return static_cast<double>(value);
  }
};

int main() {
  Number n(42);

  int i = n;
  double d = n;

  std::cout << "int: " << i << "\n";
  std::cout << "double: " << d << "\n";
}
```


```text
//<o>
int: 42
double: 42
```


In this example, we define two conversion operators in the `Number` class:

- `operator int()` converts a `Number` object to an `int`.
- `operator double()` converts a `Number` object to a `double`.

These conversion operators are defined as member functions with no parameters and a return type of the target type (`int` or `double`). They allow objects of the `Number` class to be implicitly converted to `int` or `double` when needed.


In the `main` function, we create a `Number` object `n` with a value of 42. We then assign `n` to an `int` variable `i` and a `double` variable `d`. The conversion operators are implicitly called to convert the `Number` object to the respective types.


By overloading conversion operators, we provide a way to seamlessly use objects of our custom type in contexts where other types are expected. This can make the code more concise and expressive.


However, it's important to use conversion operators judiciously, as they can sometimes lead to unexpected or ambiguous behavior if not designed carefully. Consider providing explicit conversion functions or constructors when implicit conversions may not be desired.


</FAQ>



Discover operator overloading, allowing us to define custom behavior for operators when used with our custom types

Overloading the Subscript Operator

Overloading the Function Call Operator

Overloading Comparison Operators

Overloading Arithmetic Assignment Operators

Overloading the Stream Insertion Operator

Overloading Operators for Type Conversions

Added summary, updated references, published FAQs

Added AI assistant, table of contents and references

Intro to C++

Operator Overloading

The `this` pointer

Operator Overloading in C++

C++ Operator Overloading

UPDATED FOR C++23 | Discover operator overloading, allowing us to define custom behavior for operators when used with our custom types | Clear explanations and simple code examples

Overloading the Subscript Operator

How can I overload the subscript operator [] for my custom type?

Operator Overloading

What is the purpose of overloading the function call operator ()?

How can I overload comparison operators like == and < for my custom type?

How can I overload arithmetic assignment operators like += and *= for my custom type?

How can I overload the << operator to print objects of my custom type?

Can I overload operators to perform type conversions for my custom type?

Operator Overloading

Professional C++

This course includes:

Professional C++

How can I overload the subscript operator `[]` for my custom type?

What is the purpose of overloading the function call operator `()`?

How can I overload comparison operators like `==` and `<` for my custom type?

How can I overload arithmetic assignment operators like `+=` and `*=` for my custom type?

How can I overload the `<<` operator to print objects of my custom type?