Getting our machines set up for C++ development, and introducing the fundamental building blocks of programming - variables.

Getting our computer set up so we can create and build C++ programs. Then, creating our very first application

Setting up a C++ Development Environment

An introduction to the building blocks of our software - objects, and the variables that can be associated with them.

Objects, Variables and Types

Creating variables to store and update the data that describes our objects.  We also introduce comments, allowing us to describe our code in plain language.

Creating Variables

An introduction to the different types of numbers in C++, and how we can do basic math operations on them.

Numbers

An overview of the fundamental true or false data type, how we can create them, and how we can combine them.

Booleans - `true` and `false` values

Explore how C++ programs store and manage numbers in computer memory, including integer and floating-point types, memory allocation, and overflow handling.

Types and Literals

Creating a tiny program using numbers and booleans, then adding some breakpoints so we can step through our code in a debugger.

Introduction to Debugging

Types and Variables

Discover how we can package our code into reusable functions that we can easily call.  Then, learn how we can use conditionals and loops to control the flow of our program.

An introduction to functions - reusable blocks of code that we can use to break our application into smaller pieces.

Creating and Calling Functions

An introduction to how our function calls create a call stack, and how we can navigate it in a debugger.

The Call Stack and Debugging Functions

Use booleans and if statements to make our functions and programs more dynamic, choosing different execution paths.

Conditional Logic

Learn an alternative way to write conditionals, which is often used when we want to take different paths based on a specific value

Switch Statements

Allow our functions to communicate with their caller by returning values when they complete

Function `return` Statements

Going into more depth on what is happening when a variable is used as a different type

Implicit Conversions and Narrowing Casts

Making our functions more useful and dynamic by providing them with additional values to use in their execution

Function Arguments and Parameters

Learn more about how and when we can access variables, by understanding the importance of the scope in which they exist.

Scope

Understand what function prototypes are, and learn how we can use them to let us order our code any way we want.

Forward Declarations

Learn how we can use loops to iterate over a block of code, executing it as many times as needed.

Loops

Learn how we can use the modulus operator to get the remainder of integer division, and some common use cases.

The Modulus Operator (`%`)

Put everything we've learned in this chapter to the test by creating a C++ version of the Fizz Buzz game.

Fizz Buzz

Learn how the `&&` and `||` operators are optimized with short-circuit evaluation, only evaluating expressions when necessary

Short-circuit Evaluation

Functions, Conditionals and Loops

Classes and structs are the fundamental feature of object oriented programming.  In this chapter, we will see how we can set them up, and how we can use them to create the custom types our program needs.

Learn how to define, instantiate, and utilize classes, understanding how they form the backbone of object-oriented programming.

Abstraction and Classes

A guide to encapsulation, class invariants, and controlling data access with `public` and `private` specifiers.

Encapsulation and Access Specifiers

Learn about special functions we can add to our classes, control how our objects get created and destroyed.

Constructors and Destructors

Discover the role of structs, how they differ from classes, and how to initialize them without requiring a constructor.

Structs and Aggregate Initialization

This lesson introduces operator overloading, a fundamental concept to create more intuitive and readable code by customizing operators for user-defined types

Operator Overloading

This lesson introduces Structured Binding, a handy tool for unpacking simple data structures

Structured Binding

Classes and Structs

See how we can use inheritance to organise our classes into a hierarchy, unlocking a massive range of possibilities for building more complex software

In this lesson, we explore C++ inheritance, guiding you through creating and managing class hierarchies to streamline your code

Inheritance

Learn about `protected` class members in C++, including how and when to use them in your code, especially in the context of inheritance and class design

Protected Class Members

This lesson introduces Member Initializer Lists, focusing on their advantages for performance and readability, and how to use them effectively

Member Initializer Lists

This lesson provides an in-depth exploration of using inherited methods and variables in C++, covering constructor calls, variable modification, and function shadowing

Working with Inherited Members

An introduction to working with memory, and how we represent memory locations using references and pointers

This lesson introduces references, explaining how they work, their benefits, and their role in performance and data manipulation

References

This lesson provides a thorough introduction to pointers in C++, covering their definition, usage, and the distinction between pointers and references

Pointers

Learn about the `this` pointer in C++ programming, focusing on its application in identifying callers, chaining functions, and overloading operators.

The `this` Pointer

Learn about an important consideration when returning pointers and references from functions

Dangling Pointers and References

Memory, References and Pointers

An introduction to polymorphism - the key tool that let us build more complex programs whilst keeping our code simple.

This lesson provides an in-depth look at function overloading in C++, covering its importance, implementation, and best practices

Function Overloading

Explore the concept of static casting in C++, including examples and best practices for converting data types at compile time

Static Casting

This lesson provides an introduction to virtual functions and overrides, focusing on their role in enabling runtime polymorphism

Virtual Functions and Overrides

Get to grips with downcasting in C++, including static and dynamic casts. This lesson provides clear explanations and practical examples for beginners

Downcasting

Polymorphism

Go deeper on what is happening when we build our software.  Learn how we can use the preprocessor to automatically modify our source code before it is compiled, and how the linker connects our program together.

Explore the essential concepts of C++ preprocessing, from understanding directives to implementing macros

Preprocessor Definitions

Discover how the `#include` directive helps us include library features and split our project across multiple files.

The `#include` Directive

Explore how header files and linkers streamline C++ programming, learning to organize and link our code effectively

Header Files

The Preprocessor and the Linker

Discover additional methods and techniques to keep our data and code organised.

Learn the essentials of using namespaces to organize your code and handle large projects with ease

Namespaces

Learn about Enums and how they offer an efficient way to handle predefined values in your code

Enums

This lesson introduces the `using` keyword in C++, focusing on namespaces, enums, and type aliasing

The `using` Keyword

Namespaces and Enums

Learn how to store collections of objects, and take control of how memory is managed

Explore the fundamentals of dynamic arrays with an introduction to `std::vector`

Dynamic Arrays using `std::vector`

Learn how to manage dynamic memory using unique pointers and the concept of memory ownership

Memory Ownership and Smart Pointers

Explore advanced techniques for managing object copying and resource allocation

Copy Constructors and Operators

Learn the techniques and pitfalls of manual memory management in C++

Managing Memory Manually

Arrays and Dynamic Memory

Techniques to simplify our code, making it easier to understand and maintain

This lesson covers how we can ask the compiler to infer what types we are using through the `auto` keyword

Automatic Type Deduction using `auto`

Learn the intricacies of using `const` and how to apply it in different contexts

Constants and `const`-Correctness

This lesson provides an overview of effective commenting strategies, including Javadoc style commenting for automated documentation

Effective Comments and Javadoc

This lesson introduces the concept of Style Guides and ClangFormat, focusing on how to achieve consistency in our code

Style Guides and Automatic Code Formatting

An introduction to static analysis tools, and how they can help beginners learn faster and improve code quality

Static Analysis

Explore the fundamentals of attributes, including `[[nodiscard]]`, `[[likely]]`, and `[[deprecated]]`

Attributes

Clean Code

A collection of lessons covering a variety of topics worth learning as a beginner

This lesson covers the basics of using randomness, with practical applications

Random Number Generation

Learn the basics of the chrono library and discover how to effectively manage durations, clocks, and time points

Dates, Times and Durations

A detailed guide to string formatting using C++20's `std::format()`, and C++23's `std::print()`

String Interpolation

Learn how to overload the `<<` operator, so our custom types can stream information directly to the console using `std::cout`

Overloading the `<<` Operator

This lesson introduces system calls, and how to use them to clear the terminal

System Calls and Terminal Management

This lesson introduces the fundamentals of capturing user input, using `std::cin` and `std::getline()`

User Input in the Terminal

Unravel the fundamentals of bitwise operators and bit flags in this practical lesson

Bitwise Operators and Bit Flags

Odds and Ends

This course is designed for beginners. We'll take you from the fundamentals and lay a solid foundation for creating real-world programs and learning more advanced concepts.

Become a software engineer with C++.  Starting from the basics, we guide you step by step along the way

This course teaches the fundamentals of C++ while instilling habits used by real-world developers. You'll gain practical experience with concepts that are the foundation of all modern programming.

No previous programming experience is needed - we start from the basics.

Start your Journey

We explain every line of code we're using, so you understand exactly what is happening.

Understand Every Line of Code

Everything we create is organised and implemented using modern, professional practices.

Use Professional Best Practices

We don't just explain what we're doing, but also why. This builds transferrable skills, so you can take what you've learnt and apply them to your own projects.

Focus on Transferrable Skills

No paywalls, no ads - the course is completely free with unlimited access

Free and Unrestricted Access

We break complex concepts into manageable steps, making even advanced topics feel approachable.

Step-by-Step Learning

What You'll Learn

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

Professional C++

If you're already familiar with the basics of C++ and object oriented programming, you may want to skip to the advanced course.  It starts with a quick summary of everything we cover here.

Already Familiar with Programming?

Intro to C++ Programming

Operator overloading helps us write more intuitive and readable code. While we could use regular functions, operators make our code feel more natural and match how we think about operations mathematically. Let's look at an example:


```c++
#include <iostream>

struct Vector3 {
  float x, y, z;
};

// Without operator overloading
Vector3 addVectors(const Vector3& a, const Vector3& b) {
  return Vector3{a.x + b.x, a.y + b.y, a.z + b.z};
}

// With operator overloading
Vector3 operator+(const Vector3& a, const Vector3& b) {
  return Vector3{a.x + b.x, a.y + b.y, a.z + b.z};
}

int main() {
  Vector3 pos{1, 2, 3};
  Vector3 movement{4, 5, 6};

  // Without operator overloading
  Vector3 result1{addVectors(pos, movement)};

  // With operator overloading
  Vector3 result2{pos + movement};  //<h>

  std::cout
    << "x: " << result2.x
    << ", y: " << result2.y
    << ", z: " << result2.z << "\n";
}
```


```plain text
//<o>
x: 5, y: 7, z: 9
```


The operator version is shorter and reads more naturally - it looks just like adding regular numbers. This becomes even more valuable when we chain operations:


```c++
// Clear and intuitive
Vector3 finalPos{pos + movement * 2 - offset};

  // Harder to read
Vector3 finalPos{
  subtractVectors(
    addVectors(
      pos, multiplyVectors(movement, 2)
    ),
    offset
  )
};
```


Operator overloading also helps maintain consistency with built-in types. When we see `a + b`, we intuitively understand what it means regardless of whether `a` and `b` are integers, floating-point numbers, or our custom `Vector3` type.


This consistent syntax makes our code more maintainable and reduces the cognitive load when reading it. It's especially valuable in mathematical or scientific code where these operations have clear, well-understood meanings.

Why Use Operator Overloading?

Yes, you can absolutely overload operators to work with different types! This is a common and useful practice, especially for mathematical types like our `Vector3`. Let's implement multiplication with both `int` and `float`:


```c++
#include <iostream>

struct Vector3 {
  float x, y, z;

  // Multiply Vector3 by float
  Vector3 operator*(float scalar) const {
    return Vector3{
      x * scalar, y * scalar, z * scalar
    };
  }

  // Multiply Vector3 by int
  Vector3 operator*(int scalar) const {
    return Vector3{
      x * scalar, y * scalar, z * scalar
    };
  }
};

// Allow float * Vector3
Vector3 operator*(float scalar, const Vector3& vec) {
  return vec * scalar;  // Reuse the member operator
}

// Allow int * Vector3
Vector3 operator*(int scalar, const Vector3& vec) {
  return vec * scalar;  // Reuse the member operator
}

int main() {
  Vector3 vec{1.0f, 2.0f, 3.0f};

  // Using different numeric types
  Vector3 result1{vec * 2};     // Using int
  Vector3 result2{vec * 2.5f};  // Using float

  // Using float on the left side
  Vector3 result3{3.0f * vec};

  std::cout << "Result2: x=" << result2.x
    << ", y=" << result2.y
    << ", z=" << result2.z << "\n";
}
```


```plain text
//<o>
Result2: x=2.5, y=5, z=7.5
```


You can overload operators for any types that make sense in your context. Some other common examples include:

- Multiplying a vector by a double for high-precision calculations
- Adding a position vector to a direction vector
- Multiplying a matrix by a vector
- Adding a time duration to a timestamp

The key is to implement operators that make semantic sense - if the operation would make sense mathematically or logically, it's probably a good candidate for operator overloading.


Remember that when overloading operators with different types, you might need to consider both orderings (`vector * scalar` and `scalar * vector`) if you want the operation to work both ways.

Overloading With Different Types

Yes, parameter order definitely matters in operator overloading! C++ treats `a * b` as a different operation from `b * a`. Let's see this in action:


```c++
#include <iostream>

struct Vector3 {
  float x, y, z;
};

// Vector3 * int
Vector3 operator*(const Vector3& vec, int scalar) {
  std::cout << "Called Vector3 * int\n";
  return Vector3{
    vec.x * scalar, vec.y * scalar, vec.z * scalar
  };
}

// int * Vector3
Vector3 operator*(int scalar, const Vector3& vec) {
  std::cout << "Called int * Vector3\n";
  return Vector3{
    vec.x * scalar, vec.y * scalar, vec.z * scalar
  };
}

int main() {
  Vector3 vec{1.0f, 2.0f, 3.0f};

  // Calls first overload
  Vector3 result1{vec * 2};  //<h>

  // Calls second overload
  Vector3 result2{2 * vec}; //<h>
}
```


```plain text
//<o>
Called Vector3 * int
Called int * Vector3
```


This distinction is important because:

- Different parameter orders require different overloads
- The compiler looks for an exact match first
- Some operations are naturally asymmetric

For commutative operations (where order doesn't affect the result), it's common to implement one version in terms of the other:


```c++
Vector3 operator*(const Vector3& vec, int scalar) {
  return Vector3{
    vec.x * scalar, vec.y * scalar, vec.z * scalar
  };
}

Vector3 operator*(int scalar, const Vector3& vec) {
  return vec * scalar;  // Reuse the other overload //<h>
}
```


However, for non-commutative operations like matrix multiplication or division, the order is mathematically significant and you'll want distinct implementations for each order.

Parameter Order in Operators

While C++ technically allows you to make operators behave however you want, doing so is generally considered poor practice. Let's look at why, and what guidelines you should follow:


```c++
#include <iostream>

struct BadVector3 {
  float x, y, z;

  // BAD: + operator performs multiplication //<w>
  BadVector3 operator+(
    const BadVector3& other) const {
    // Multiplying instead of adding!
    return BadVector3{
      x * other.x,
      y * other.y,
      z * other.z
    };
  }
};

struct GoodVector3 {
  float x, y, z;

  // GOOD: + operator performs addition as expected //<h>
  GoodVector3 operator+(
    const GoodVector3& other) const {
    return GoodVector3{
      x + other.x,
      y + other.y,
      z + other.z
    };
  }
};

int main() {
  BadVector3 v1{2, 3, 4};
  BadVector3 v2{3, 4, 5};

  // Misleading! Actually multiplies
  BadVector3 result{v1 + v2};

  std::cout << "Unexpected result: "
  << result.x << "\n"; // Prints 6, not 5!
}
```


```c++
//<o>
Unexpected result: 6
```


## Guidelines for Operator Behavior

- Follow the principle of least surprise - operators should behave as users expect
- `+` should perform addition or concatenation
- should perform multiplication or scaling
- `==` should test for equality
- should perform subtraction or negation
- `+=` should modify the left operand by adding the right operand

## Why These Guidelines Matter


If operators behave unexpectedly:


```c++
Vector3 pos{1, 2, 3};
Vector3 movement{4, 5, 6};

// Developer expects addition,
// but gets multiplication instead!
Vector3 newPos{pos + movement};//<w>
```


Breaking these conventions makes code:

- Harder to read and understand
- More prone to bugs
- Less maintainable
- Confusing for other developers

Instead of overloading operators to do unexpected things, create appropriately named functions for those operations. This makes your code's behavior clear and predictable.

Unconventional Operator Behavior

Yes, you can overload operators to work with different custom types! This is particularly useful when you have related types that need to interact. Here's a practical example:


```c++
#include <iostream>

struct Vector3 {
  float x, y, z;
};

struct Point3D {
  float x, y, z;

  // Add a vector to this point to get a new point
  Point3D operator+(const Vector3& vec) const {
    return Point3D{x + vec.x, y + vec.y, z + vec.z};
  }
};

// Free function to handle vector + point
Point3D operator+(
  const Vector3& vec, const Point3D& point
) {
  return point + vec;  // Reuse the member operator
}

int main() {
  Point3D startPos{0.0f, 0.0f, 0.0f};
  Vector3 movement{1.0f, 2.0f, 3.0f};

  // Both operations work!
  Point3D pos1{startPos + movement};
  Point3D pos2{movement + startPos};

  std::cout << "New position: "
    << pos1.x << ", "
    << pos1.y << ", "
    << pos1.z << "\n";
}
```


```plain text
//<o>
New position: 1, 2, 3
```


Some key considerations when working with different types:

- Make sure the operation makes semantic sense (e.g., Point + Vector = Point)
- Consider implementing both orderings if commutative
- Be clear about which type owns the operator implementation
- Think about type conversion implications

Here's another example showing vector projection:


```c++
struct Vector3 {
  float x, y, z;

  // Project this vector onto another vector
  float operator|(const Vector3& other) const {
    return (
      x * other.x +
      y * other.y +
      z * other.z
    ) / (
      other.x * other.x +
      other.y * other.y +
      other.z * other.z
    );
  }
};
```


Remember that while you can overload operators between different types, you should ensure the operations make mathematical or logical sense in your domain.

Operators Across Different Types

No, C++ does not allow you to create new operators - you can only overload the existing ones. Here's a complete list of operators you can overload, and some alternatives for when you need custom operations:


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

struct Vector3 {
  float x, y, z;

  // We can overload existing operators
  Vector3 operator+(const Vector3& other) const {
    return Vector3{
      x + other.x, y + other.y, z + other.z
    };
  }

  // But we can't create a ** operator for power
  // Instead, we create a named function
  Vector3 pow(float exponent) const {
    return Vector3{
      std::pow(x, exponent),
      std::pow(y, exponent),
      std::pow(z, exponent)
    };
  }
};

int main() {
  Vector3 vec{2.0f, 3.0f, 4.0f};

  // This works - using existing operator
  Vector3 sum{vec + vec};

  // This won't compile - ** isn't a valid operator
  Vector3 powered{vec ** 2.0f};  //<e>

  // Instead, use the named function
  Vector3 squared{vec.pow(2.0f)};

  std::cout << "Squared: " << squared.x
    << ", " << squared.y
    << ", " << squared.z << "\n";
}
```


```plain text
//<oe>
error: invalid operator **
```


The operators you can overload in C++ include:

- Arithmetic: `+`, , , `/`, `%`
- Compound assignment: `+=`, `=`, `=`, `/=`, `%=`
- Comparison: `==`, `!=`, `<`, `>`, `<=`, `>=`
- Increment/Decrement: `++`, `-`
- Member access: `>`, `[]`
- Function call: `()`
- Bitwise: `&`, `|`, `^`, `~`, `<<`, `>>`

For operations that don't map to existing operators, you should create well-named member functions or free functions instead. This often leads to more readable and maintainable code anyway!

Creating Custom Operators

<Excerpt>


In the previous lesson, we created a simple `Vector3` struct to hold 3 numbers, which we could use to represent concepts like a position in a 3D world:


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


It would be nice if we were able to use operators like `+` and `+=` with our new custom type, in much the same way we were able to do with built-in types like `int` and `float`.


For example, we would like to be able to do things like this:


```c++
Vector3 CurrentPosition { 1.0, 2.0, 3.0 };
Vector3 Movement { 4.0, 5.0, 6.0 };

// Create a new object using the + operator
Vector3 NewPosition { CurrentPosition + Movement };
```


After running the above code, we'd want `NewPosition` to be a `Vector3` with the values `5.0`, `7.0`, and `9.0`.


For this, we need to _**overload operators**_.


</Excerpt>


<Ad />


## Operators are Functions


In C++, operators are simply functions that have a specific name, a specific parameter list, and are called in a slightly different way.


When we write code like `1 + 2`, the compiler is going to try to call a function with the following properties:

- Has the name of `operator+`
- Accepts an `int` as the first argument
- Accepts an `int` as the second argument

With that in mind, the function prototype that allows two of our `Vector3` objects to use the `+` operator could have this prototype:


```c++
void operator+(Vector3 a, Vector3 b);
```


It is up to us to define what an operator does, and what it returns.  Naturally, when we see `+`, we'd expect that operator to add the two operands together, and return the result.


So let's update the function's return type and body to do that:


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


With that, we can now easily add our `Vector3` objects together:


```c++
#include <iostream>
using namespace std;

struct Vector3 {
  float x;
  float y;
  float z;
};

Vector3 operator+(Vector3 a, Vector3 b){
  return Vector3{
    a.x + b.x,
    a.y + b.y,
    a.z + b.z
  };
}

int main(){
  Vector3 CurrentPosition{1.0, 2.0, 3.0};
  Vector3 Movement{4.0, 5.0, 6.0};
  Vector3 NewPosition{
    CurrentPosition + Movement
  };

  std::cout
    << "x= " << NewPosition.x
    << ", y = " << NewPosition.y
    << ", z = " << NewPosition.z;
}
```


```c++
//<o>
x= 5, y = 7, z = 9
```


<Advanced>


### Passing by Reference


Our operator works correctly, but there is a small change we could make to improve its performance.


With our current implementation, our operands are being **copied** into our function body, which is an unnecessary performance cost.


Users familiar with other programming languages may recognize this behavior as _**pass by value**_, which C++ does by default.


We introduce this topic in a dedicated lesson later in the course so don't worry if it doesn't make sense for now.  But for those more comfortable, we can change our parameters to be _**passed by reference**_ by appending an ampersand, `&`, to their types in our function parameter list:


```c++
Vector3 operator+(Vector3& a, Vector3& b){//<h>
  return Vector3{
    a.x + b.x,
    a.y + b.y,
    a.z + b.z
  };
}
```


</Advanced>


## Operand Order Matters


C++ does _**not**_ consider an expression like `A * B` to be equivalent to `B * A`.


This has implications for our operator overloading.  For example, if we wanted to give our `Vector3` the ability to be multiplied by an `int`, we typically need to implement two variations.


We need to implement one where the `int` is the left operand, to support expressions like `2 * MyVector`:


```c++
// num * vec
Vector3 operator*(int num, Vector3 vec) {//<h>
  return Vector3{
    vec.x * num, vec.y * num, vec.z * num
  };
}
```


And we need to implement a second variation where the `int` is the right operand, to support expressions like `MyVector * 2`.  The function body is exactly the same in this example - we have simply reordered the parameters:


```c++
// vec * num
Vector3 operator*(Vector3 vec, int num) {//<h>
  return Vector3{
    vec.x * num, vec.y * num, vec.z * num
  };
}
```


In situations like this, where the parameter order doesn't change the output of our operation, we can implement one function in terms of the other.


For example, if someone calls the `Vector3 * int` variation, our function can simply call the `int * Vector3` implementation by reordering the operands:


```c++
// num * vec
Vector3 operator*(int num, Vector3 vec) {
  return Vector3{
    vec.x * num, vec.y * num, vec.z * num
  };
}

// vec * num
Vector3 operator*(Vector3 vec, int num) {
  return num * vec;//<h>
}
```


<Definition>


### Commutative Operations


An operation where the order of operands doesn't matter is referred to as **commutative**.  


Addition of integers is an example of a commutative operation, as $x + y$ and $y + x$ are equivalent.  Reordering (or "commuting") the operands does not change the result.


Subtraction is **not** commutative, as $x - y$ and $y - x$ do not necessarily give the same result.


</Definition>


<Quiz title="Operator Overloading">


<Question>


What function prototype would we need to allow two `Vector3` objects to be subtracted using the `-` operator, returning a new `Vector3`?  For example:


```c++
Vector3 CurrentPosition { 1.0, 2.0, 3.0 };
Vector3 Reverse { 4.0, 5.0, 6.0 };

Vector3 NewPosition{CurrentPosition - Reverse};//<h>
```


<Answer>


`Vector3 -(Vector3 a, Vector3 b)`


<Feedback>


Consider the syntax used for defining operators in C++. The operator name should be prefixed with `operator`.


</Feedback>


</Answer>


<Answer>


`operator- (Vector3 a, Vector3 b)`


<Feedback>


Remember to specify the return type for the function to indicate what the operation produces.


</Feedback>


</Answer>


<Answer isCorrect>


`Vector3 operator- (Vector3 a, Vector3 b)`


<Feedback>


Correct! This prototype matches the expected format for operator overloading


</Feedback>


</Answer>


</Question>


<Question>


What function would we need to allow a `Vector3` to be multiplied by an `int` using the `*` operator?  For example:


```c++
Vector3 CurrentPosition { 1.0, 2.0, 3.0 };

Vector3 NewPosition { CurrentPosition * 5 };//<h>
```


<Answer isCorrect>


```c++
//<qa>
Vector3 operator*(Vector3 a, int b) {
  return Vector3 {
    a.x * b, a.y * b, a.z * b
  };
}
```


<Feedback>


Good job! This correctly defines the operator for multiplying a `Vector3` with an `int`.


</Feedback>


</Answer>


<Answer>


```c++
//<qa>
Vector3 operator*(Vector3 a, Vector3 b) {
  return Vector3 {
    a.x * b, a.y * b, a.z * b
  };
}
```


<Feedback>


Look closely at the types of operands used in the operation. Does the second operand match with the example given?


</Feedback>


</Answer>


<Answer>


```c++
//<qa>
Vector3 operator*(int a, Vector3 b) {
  return Vector3 {
    b.x * a, b.y * a, b.z * a
  };
}
```


<Feedback>


The order of the arguments matters here


`CurrentPosition * 5` is going to call a function that accepts a `Vector3` as the first argument, and an `int` as the second


</Feedback>


</Answer>


</Question>


</Quiz>


<Ad />


## Overloading Operators with Member Functions


The previous examples implemented operator overloading using a standalone function, outside of any class or struct.  These are sometimes referred to as _**free functions**_.


However, it is also possible to implement operators as member functions, within the relevant class or struct.


Let's see what the `+` operator might look like using that method:


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

  Vector3 operator+(Vector3 Other) {
    return Vector3 {
      x + Other.x,
      y + Other.y,
      z + Other.z
    };
  }
};
```


The key thing to note in the declaration of `operator+` as a member function is that there is only one parameter.


This might be confusing, as the `+` operator has two operands - a left and a right.  When we created this as a free function earlier, we needed to have two parameters:


```c++
Vector3 operator+(Vector3 a, Vector3 b);
```


However, when we overload the operator as a member function, the function is called within the _**context**_ of the left operand.  So for example, in an expression like `x + Other.x`, `x` is accessing the `x` member of the left operand, whilst `Other.x` is accessing the `x` member of the right operand.


<Quiz title="Operator Overloading as a Member Function">


<Question>


How can we allow our `Vector3` objects to be multiplied with a `float` using a member function operator overload?  For example:


```c++
struct Vector3 {
  float x, y, z;

  // Add a function here
};

Vector3 MyVector { 4.0, 5.0, 6.0 };
Vector3 BigVector { MyVector * 3.0 };//<h>
```


<Answer isCorrect>


```c++
//<qa>
struct Vector3 {
  float x, y, z;
  
  Vector3 operator*(float Other) {
    return Vector3 {
      x * Other,
      y * Other,
      z * Other
    };
  }
};
```


<Feedback>


You got it!


</Feedback>


</Answer>


<Answer>


```c++
//<qa>
struct Vector3 {
  float x, y, z;
  
  Vector3 operator*(Vector3 this, float Other) {
    return Vector3 {
      this.x * Other,
      this.y * Other,
      this.z * Other
    };
  }
};
```


<Feedback>


When overloading an operator as a member function, the left operand is not available as a parameter


</Feedback>


</Answer>


<Answer>


```c++
//<qa>
struct Vector3 {
  float x, y, z;
  
  Vector3 operator*(float Other) {
    x *= Other;
    y *= Other;
    z *= Other;
  }
};
```


<Feedback>


This is trying to modify the left operand. We can do this from an operator if needed, but this function is stating it will return a `Vector3`, and it is not doing that.


</Feedback>


</Answer>


</Question>


</Quiz>


## Unary Operators


The previous sections are all examples of _**binary operators**_.  Binary operators have two operands - a left, and a right.


```c++
// Add LeftOperand and RightOperand
LeftOperand + RightOperand;
```


Some operators take only one operand - these are called unary operators.  `++` is an example of a unary operand.


```c++
// Increment SomeNumber
SomeNumber++;
```


Some symbols, such as `-`, can be used either as a unary or binary operand.  The unary `-` is generally used to get the negative form of an operand, whilst the binary `-` is used to subtract the right operand from the left:


```c++
int Number{5};

-Number; // Return -5
Number - Number; // Return 0
```


We implement unary and binary operators in exactly the same way.  The only difference is the number of parameters our function will have:

- Overloading a binary operator as a standalone function will use 2 parameters
- Overloading a binary operator as a member function will use 1 parameter
- Overloading a unary operator as a standalone function will use 1 parameter
- Overloading a unary operator as a member function will use no parameters

Below, we overload the unary `-` operator using a member function:


```c++
struct Vector3 {
  float x;
  float y;
  float z;
  
  Vector3 operator-() {
    return Vector3 { -x, -y, -z };
  }
};
```


<Quiz title="Overloading Unary Operators">


<Question>


How would we overload the unary `-` operator using a standalone function?


<Answer>


```c++
//<qa>
Vector3 operator-() {
  return Vector3 { -this.x, -this.y, -this.z };
}
```


<Feedback>


Not quite!  When we're overloading a unary operator from a standalone function, we receive the operand as a parameter.


</Feedback>


</Answer>


<Answer>


```c++
//<qa>
Vector3 operator-(Vector3) {
  return {-Vector3.x, -Vector3.y, -Vector3.z};
}
```


<Feedback>


We need to use the correct syntax for function parameters.


</Feedback>


</Answer>


<Answer isCorrect>


```c++
//<qa>
Vector3 operator-(Vector3 a) {
  return Vector3 { -a.x, -a.y, -a.z };
}
```


<Feedback>


You got it!


</Feedback>


</Answer>


</Question>


</Quiz>


## Operator Prototypes and Definitions


Like any other member function, we can declare and define our functions in different locations, if we prefer:


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

  // declaration
  Vector3 operator+(Vector3 Other);
};
```


```c++
// definition
Vector3 Vector3::operator+(Vector3 Other) {
  return Vector3 {
    x + Other.x,
    y + Other.y,
    z + Other.z
  };
}
```


<Preview>


### Chaining Operators


In this lesson, we've focused on operators that are typically expected to return **new** objects, such as the `+` and `*` operators.  After using an expression like `SomeVector * 2`, we do not expect `SomeVector` to have changed - we just want that expression to return a new, different `Vector`.


However, some operators **are** expected to change their operands.  Common examples include `++` and `*=`.  That is, if we were to use an expression like `SomeVector *= 2`, we **would** expect `SomeVector` to be updated. 


We've intentionally avoided these operators for now, as we need to learn some more advanced concepts first.


Specifically, we haven't currently covered enough to make these operators work as expected when they are chained together, for example:


```c++
--Position *= 2;
```


We have a second lesson on operator overloading later in the course, where we cover implementing these more advanced operators once we've learned all the prerequisites


</Preview>


## Summary


In this lesson, we introduced operator overloading, allowing us to extend the capability of our user-defined types, and interact with them in more expressive ways.


The key learnings are:

- Operators are implemented as simple functions in C++, with a specific naming convention using the word `operator`
- Operator overloads can be implemented using free functions or member functions, and which approach we choose has implications on what our function parameters will be
- Operators can be defined and declared in different locations, just like any other function

<Preview>


### Structured Binding


The upcoming lesson will introduce _**structured binding**_. This feature, a part of C++17, offers a more concise and readable way to handle simple types, such as the `Vector3` we've been using in this lesson.


We'll cover:

- Basics and syntax of structured binding.
- Practical application and examples of structured binding.
- Limitations on when it can be used.

</Preview>

Moved earlier in the course and refreshed content

Improved passing by reference section and flagged it as advanced

Expanded definition of commutative operations and moved it to a dedicated section

Operators in C and C++

What are the basic rules and idioms for operator overloading?

Operator Overloading in C++

C++ Operator Overloading Guidelines

{CPP}Introduction to operator overloading in C++. Discover how to use operators with custom types

{CPP}C++ Fundamentals: Operator Overloading

Overloading Operators with Member Functions

Operator Overloading

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers