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

<Excerpt>


We have previously looked at how we can add comments to our code using `//` and `/* */`.


```c++
class Character {
 public:
  // This is a single-line comment
  int GetHealth() { return mHealth; }

 private:
  /* This comment can span
  * multiple lines
  */
  int mHealth;
};
```


Whilst knowing _how_ to comment is useful, there is a more nuanced topic, around knowing _when_ to comment.


</Excerpt>


## Commenting for Future Work


Often when we're writing a class or function, we want our code to do something that is not currently possible.


Perhaps the functionality is being worked on by a colleague and they're not done yet, or it's just something we know we'll need in the future, but don't want to work on just yet.


In those scenarios, it's common to leave a comment in our code, noting where this integration will happen:


```c++
// TODO: send event data to the analytics
// service once it is ready
void TrackEvent(Event& Event) {}
```


By convention, we prepend `TODO` or `NYI` (not yet implemented) to these comments.  This means that, before we release, we can do a project-wide text search for `TODO` to determine if anything is outstanding.


Some tools interact with comments in this style too - for example, the Visual Studio Task List (available from the _View_ menu) presents all of the `TODO` comments in our project.


## Comments to Explain Complexity


Another good place to add comments is to code that is simply too complex to understand.  Our first instinct should be to determine if we can reduce the complexity - we provide some examples of that later in the lesson.


But in some scenarios, reducing the complexity is not desirable as it would reduce performance, in a function where performance is very important.


In these contexts, an explanatory comment, often with a link to provide more information, can be very helpful:


```c++
// This is an implementation of the Fast
// Inverse Square Root algorithm - see:
// wikipedia.org/wiki/Fast_inverse_square_root
float InvSqrt(float x) {
  using std::bit_cast, std::uint32_t;

  const float y { bit_cast<float>(
    0x5f3759df - (bit_cast<uint32_t>(x) >> 1)
  )};
  return y * (1.5f - (x * 0.5f * y * y));
}
```


## Commenting to Give Context


Often, comments are used to explain _**what**_ complex code is doing, but that is rarely necessary.  Anyone who needs to understand what code is doing can take the time to analyze it.


It's often more useful to explain _**why**_ code is doing something, as that information isn't as easy to regenerate.


Often, we have to do unusual things in our code that may be confusing to anyone reading it in the future.  They'll understand _**what**_ our code is doing, but not _**why**_.


When this happens, it can be helpful to add a comment to explain:


```c++
void TrackEvent(Event& Event) {
  // We redact user email addresses to
  // protect personal data and privacy
  Event.User.Email = "";

  SendToAnalytics(Event);
}
```


## Comments as Documentation


When other developers (or ourselves, in the future) want to get an idea of what classes can do, we're generally going to explore in one of two ways:

1. Check the header file
2. Use IDE features, such as tooltips and autocomplete

We can infer quite a lot in this way.  The header files are going to list all the functions and their method signatures.


When we're using an IDE, the UI is typically going to find the public variables and functions of the class we're using and provide some information.  By looking at the function name, we can hopefully get an idea of what the function does.  Similarly, by looking at the parameter types and names, we can usually get an idea of what arguments we need to provide.


The following screenshot is an example of this from Visual Studio, which calls this feature _**IntelliSense**_.


<Img file="is_comments1.png" width="882" height="247" alt="Screenshot showing an IntelliSense tooltip" blurHash="L17BAn-p009Y00%M~qM{ITRit7xv" />


This is useful, but sometimes won't have all the information we might need.  Let's look at this function, for example:


```c++
bool TakeDamage(float Percent);
```


What is the `bool` that this function returns? And what is the `Percent` parameter? Is it the percentage of the character's maximum health? Or current health? Or something else?


We can further improve IntelliSense and our documentation by adding comments to our header file. By adding a simple comment above the method signature, our code can be described in plain language:


```c++
/* Take a percentage of the character's 
  * maximum health as damage.  Returns
  * true if the damage was Lethal
 */
 bool TakeDamage(float Percent){};
```


Most IDEs will also show this comment when we use our classes, or hover over calls to our function:


<Img file="is_comments2.png" width="937" height="445" alt="Intellisense showing a comment" blurHash="L17nUb4n00D$00_3?bj?4T-;-=kC" />


## Structured Comments and Javadoc


Comments can be even more powerful when we follow a specific pattern. If we format our comments in a structured style, other systems will be able to read and understand our comments at a programmatic level.


Take this style of commenting, for example:


```c++
/**
 * Take damage based on the character's
maximum health.
 * @param Percent - The percentage of the
 * character's max health to inflict as damage
 * @return Whether or not the damage was lethal
 */
bool TakeDamage(float Percent);
```


If we now view our tooltip in our editor, it is likely to have been formatted in a more structured way.


<Img file="is_comments3.png" width="905" height="777" alt="Intellisense showing a js-doc formatted comment" blurHash="L07UM54T00.78__3_2D$00?b~qM_" />


These are called _**Javadoc-style comments**_, which were popularised by a documentation generator created for the Java programming language.  It features many more properties than those demonstrated here.  Javadoc comments can include things like:

- links to websites
- references to other blocks of code
- flags to inform users that the function is deprecated and they should probably use something else

When we create comments in a specific manner, they can be read and understood not just by humans, but also by other tools.  As we've seen, this includes our IDE, but there are many more use cases.


For example, [Doxygen](https://www.doxygen.nl/index.html) can use comments written in this style to automatically create documentation websites for our projects.


<Aside>


### Excluding Comments from Documentation


Sometimes we want to write comments above lines of code, but to not have those comments be interpreted as anything more than a simple comment.


Typically, a comment that uses three slashes - `///` - will not be treated as documentation.  For example, the following comment will not appear in our IDE tooltips:


```c++
/// This comment will not appear in tooltips
int Number { 4 };
```


</Aside>


<Ad />


## The Problem with Comments


Whilst comments are often useful, they can often be misused as a way to mitigate messy code.


Ideally, our code should _require_ as few comments as possible. We should strive to make our code as simple as possible, rather than having complex code and explanatory comments.


If code is confusing, our first instinct should be to determine if we can make it less confusing, rather than explain it with comments.


Code that strives to be as understandable to humans as possible, without needing additional comments or documentation, is sometimes referred to as _**self-documenting code**_.


Making our code clearer has several advantages over using comments to explain complex code.  The two main advantages are:

- Code is the real "source of truth".  Comments are ignored by the compiler, so can be misleading/wrong.  This often happens as a result of future code changes, that neglect to also update the associated comments
- The process of refactoring code to be "self-documenting" almost always improves it, making future work easier.

The rest of this section outlines the four most common ways to replace comments with better code.


### Removing Unnecessary Comments


Another common misuse of comments is those that simply explain what the code is doing.  These are unnecessary and simply add noise and maintenance overhead:


```c++
int Add(int x, int y) {
  // Return the result of adding x and y
  return x + y;
}
```


### Renaming or Adding Variables


Often, a comment that describes what a variable does can be replaced by simply improving the variable name. We can improve the following code:


```c++
// The aggression level
int Level { 0 };
```


We just need to use a more descriptive variable name:


```c++
int AggressionLevel { 0 };
```


Additionally, we often have literals in our code that warrant an explanatory comment. These literals are sometimes called "magic strings" or "magic numbers" - seemingly arbitrary values that have some special, non-obvious, meaning.


```c++
// Unicode character for a smiling emoji
Chat.Send("U+1F600");

// This URL returns our special offers
HTTP::Get("https://192.63.27.92");
```


We can make that relationship concrete and self-documenting by just creating variables.


```c++
string SmilingEmoji { "U+1F600" };
Chat.Send(SmilingEmoji);

string SpecialOffers { "https://192.63.27.92" };
HTTP::Get(SpecialOffers);
```


### Introducing Descriptive Types or Aliases


Another common source of comments is documenting properties associated with types.  We might have a variable or a set of variables that have some semantic meaning that is not immediately clear.  Below, we have three floats, and their relationship is established just through a comment


```c++
// x, y, and z positions in the world
float x { 0 };
float y { 0 };
float z { 0 };
```


Instead, we can introduce a new type that makes that relationship concrete:


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

Position WorldPosition { 0, 0, 0 };
```


Enum types are often useful for this purpose, too.  Below, we have an `int` type where the values have some hidden meaning, which we've documented in a comment:


```c++
// 0 is friendly, 1 is neutral, 2 is hostile
int AggressionLevel { 0 };
```


Instead, we should add an `enum` type to handle this:


```c++
enum class Aggression {
  Friendly, Neutral, Hostile };
auto AggressionLevel{Aggression::Friendly};
```


Where an existing type does not exactly match our requirements but comes close, we may be tempted to use it with some comments:


```c++
// Returns ability damage as a std::pair
// first is damage, second is crit chance
std::pair<int, float> GetDamageValues();
```


Instead, we should consider just introducing a new, self-documenting type:


```c++
struct AbilityDamage {
  int Damage; float CritChance;
};

AbilityDamage GetDamageValues();
```


Even if a more generic type does match our requirements, we sometimes feel a comment is warranted to specifically explain what that type contains:


```c++
// This vector only contains the abilities
// that have already been learned
std::vector<Ability> SpellBook;
```


Instead, we can do this with a type alias:


```c++
using LearnedAbilities = std::vector<Ability>;
LearnedAbilities SpellBook;
```


### Decomposing Problems using Helper Functions


When we create a complex function, composed of multiple parts, our first instinct is often to describe what is going on in that function by introducing a lot of comments.


Let's imagine we have a complex member function that looks something like this:


```c++
class Character {
 public:
  bool Attack(Character* Target) {
    // Make sure we have a target, and it is
    // valid to attack it
    if (!Target) return false;
    if (Target.Hostility == Friendly) {
      return false;
    }

    // Target is attackable, but we need to make
    // sure it is in range
    float[x1, y1, z1] = MyPosition;
    float[x2, y2, z2] = Target->Position;
    float x = x1 - x2;
    float y = y1 - y2;
    float z = z1 - z2;

    // The square root of these values will be
    // the distance
    float Distance{(x * x) + (y * y) + (z * z)};

    if (sqrt(Distance) <= 10) {
      // Attack was successful
      Target->TakeDamage();
      return true;
    }
    // Attack was unsuccessful
    return false;
  }
};
```


Breaking a big problem into smaller functions makes our code simpler, and allows us to replace our comments with descriptive function names instead.


A function that does part of the computation of another function is sometimes referred to as a _**helper function**_.


As an additional benefit, quite often these smaller, more generic functions can be useful in multiple places.  This can make future work easier, by reducing the amount of code we have to write and maintain.


<Ad />


For the above function, we can simplify it by introducing two helper functions - `isValidTarget()` and `GetDistance()`:


```c++
class Character {
 public:
  bool Attack(Character* Target) {
    if (!isValidTarget(Target)) return false;

    Target->TakeDamage();
    return true;
  }

 // ... other public members

 private:
  bool isValidTarget(const Character* Target) {
    if (!Target) return false;
    if (Target.Hostility == Friendly) {
      return false;
    }

    return GetDistance(Target->Position) > 10)
  }

  float GetDistance(Position TargetPosition) {
    float[x1, y1, z1] = MyPosition;
    float[x2, y2, z2] = TargetPosition;
    float x = x1 - x2;
    float y = y1 - y2;
    float z = z1 - z2;

    return sqrt((x * x) + (y * y) + (z * z));
  }

  // ... other private members
};
```


## Summary


This lesson provides an introduction to effective commenting and documentation.  We covered:

- **Types of Comments**: Reviewing single-line (`//`) and multi-line (`/* */`) comments.
- **Purposeful Commenting**: Learning when and how to comment, including using comments for future work (`TODO`, `NYI`) and explaining complex code.
- **Contextual Comments**: Emphasizing the importance of comments that give context and explain the 'why' behind code decisions.
- **Javadoc and Documentation**: Introducing structured commenting styles like Javadoc for better documentation and tool integration.
- **Self-documenting Code**: Strategies for writing code that is self-explanatory, reducing the reliance on external comments.

<Preview>


### Standards and Style Guides


In the next lesson, we'll explore coding standards and how they enhance the readability and maintainability of code. We'll explore the role of style guides in programming and introduce ClangFormat, a powerful tool for automatically formatting our files.


Key Topics:

- Understanding how style guides are used to create consistent programming practices in team environments.
- Introduction to ClangFormat for automatic code formatting.
- Setting up and configuring ClangFormat in your development environment.
- Examples of common style guides and how to use them in ClangFormat.

</Preview>

Effective Comments and Javadoc

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming