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>


When we build our code, it is not immediately compiled.  Instead, it is first sent to the _**preprocessor**_.


The preprocessor is a behind-the-scenes tool. It modifies our code based on special instructions we insert into our source files, known as **preprocessor directives**.


The preprocessor does not modify our original code.  It generates temporary, intermediate copies of our files, and modifies those.  Therefore, we normally don't see the modifications the preprocessor does - it happens behind the scenes.


Once the preprocessor has finished generating these temporary copies, with all the changes based on the directives we supply, they are sent off for compilation.


In this lesson, we'll explore how to use these directives to make our projects more flexible and efficient.


</Excerpt>


<Definition>


### Translation and Translation Units


The modifications to our source code before it is compiled are sometimes called _translations_.  The files that are generated by translation are sometimes called _translation units_.  It is these translation units that are sent for compilation.


</Definition>


## Preprocessor Directives


We can give instructions to the preprocessor by including specific instructions in our source code files.  These instructions are called **directives** and, when the preprocessor encounters one, it reacts accordingly.


These preprocessor directives are very powerful - they are a programming language in their own right.  They have variables, conditional statements, function-like syntax, and more.


These preprocessor directives give us a range of new abilities, which we'll cover in this chapter.  They include:

- Generating different versions of our software from the same source code.
- Defining reusable blocks of code, which we can then quickly add to our files
- Including code others have written, sometimes called library code, to let us build more advanced features quickly
- Splitting our project across multiple files, to keep everything organized.

<Quiz title="The Preprocessor">


<Question>


What is the preprocessor?


<Answer>


A system that scans our code after it is sent to the compiler to warn us of any potential issues


<Feedback>


Consider the stage at which the preprocessor operates in relation to the compilation process.


</Feedback>


</Answer>


<Answer>


The step after compilation that processes all of our compiled binary instructions into an executable file


<Feedback>


Think about the role of the preprocessor in the code compilation process and how it differs from later stages like linking and generating executables.


</Feedback>


</Answer>


<Answer isCorrect>


A system that scans our code before it is sent to the compiler. It searches for any _preprocessor directives_ it finds, and modifies our code based on those directives.


<Feedback>


This answer accurately describes the primary function of the preprocessor


</Feedback>


</Answer>


</Question>


</Quiz>


<Ad />


## Conditional Inclusion


A common use of the preprocessor is to determine what code is included in the software we build.


For example, we often want our software to behave differently when run by a developer, compared to a real-world user.  To do this, we create different versions, or _**releases,**_ of our software.


The development version might show a lot more information to help us debug issues.  In the releases we use for demos, or ultimately send to customers, all of that additional code is stripped out.


We can do that by wrapping the code we want to conditionally include between `#ifdef` and `#endif` directives:


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

int main(){
  cout << "Hello There";
#ifdef DEVELOPMENT_BUILD//<h>
  cout << "\nThis is a developer build";
#endif//<h>
}
```


In this example, `DEVELOPMENT_BUILD` is a _**preprocessor definition**_ that we can choose to set or not.  We show how to set this in the next section.


If we set `DEVELOPMENT_BUILD`, our output will be this:


```c++
//<o>
Hello There
This is a developer build
```


If we don't, our program will output:


```c++
//<o>
Hello There
```


The opposite of `#ifdef` is `#ifndef`.  This will include code if a flag is **not** defined:


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

int main(){
  cout << "Hello There";
#ifndef DEVELOPMENT_BUILD//<h>
  cout << "\nThis is a public build";
#endif//<h>
}
```


We can also use `#elif` (which means "else if") and `#else`:


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

int main(){
  cout << "Hello There";
#ifdef DEVELOPER_BUILD
  cout << "\nThis is a developer build";
#elif DEMO_BUILD
  cout << "\nThis is a demo build";
#else
  cout << "\nThis is a public build";
#endif
}
```


## Setting Preprocessor Definitions


How we set a preprocessor definition, such as our `DEVELOPMENT_BUILD` example, depends on our IDE.


In Visual Studio, we can set it by selecting _**Project**_ from the top menu bar, and visiting _Project -> Properties -> C/C++ -> Preprocessor -> Preprocessor Definitions_


<Img file="preprocessor.PNG" width="978" height="673" alt="A screenshot showing the preprocessor settings in Visual Studio" blurHash="L5RMb%4nt7M{~qIUWBxuD%?bIUof" />


Preprocessor definitions are part of Visual Studio's release configuration system.  Within Visual Studio, we can define multiple configurations, and two are usually provided by default - _Debug_ and _Release_.


We can create more configurations as needed.  Each configuration can have its own set of preprocessor definitions (and other settings), and we can then switch between configurations quickly through the user interface.


Other IDEs commonly have similar options.  In projects that use CMake, we can set preprocessor definitions using the `add_compile_definitions()` or `target_compile_definitions()` functions:


```c++
//<cmake>
add_compile_definitions(
  DEVELOPER_BUILD
  ANOTHER_DEFINITON
  YET_ANOTHER
)
```


```c++
//<cmake>
add_executable(MyProgram "main.cpp")

target_compile_definitions(
  MyProgram PUBLIC
  DEVELOPER_BUILD
  ANOTHER_DEFINITON
  YET_ANOTHER
)
```


<Aside>


### `#ifdef` Directives vs `if` Statements


A common question at this point is why would we ever need this.  After all, we can just do the same thing with `if` statements.


The key difference is _**when**_ the conditional check is done.  Preprocessor directives are analyzed at _build time_, whilst `if` statements are analyzed at _run time_.


Most things can only be checked at run time, so `if` statements are generally going to be much more common and useful.


But, if something doesn't need to be checked at run time, we should consider using the preprocessor instead.  Conditional inclusion has two big benefits over `if` statements:

- **Performance** - an `#ifdef` directive is evaluated one time - when we build our software. An `if` statement is evaluated every time the function is called, by everyone who runs our software.
- **Security** - if we include all the "secret" functionality in the code we send to users, an `if` statement won't keep it hidden. It is quite easy for someone to reverse engineer and see things that are "hidden" behind regular `if` statements. If we use `#ifdef` instead, the code is entirely removed from what we release.

</Aside>


<Quiz title="Conditional Inclusion">


<Question>


What is the purpose of the `#ifdef`, `#ifndef`, `#elif`, `#else`, and `#endif` preprocessor directives?


<Answer>


They let us check the user's system when our code is running, and take different actions based on the user's hardware, operating system, etc


<Feedback>


Recall the stage at which preprocessor directives operate and how this affects their ability to interact with the user's system.


Preprocessor directives are evaluated at "build time", not "run time".


As such, they'll have no visibility on the end user's system, or anything else that happens after our code has been compiled.


</Feedback>


</Answer>


<Answer isCorrect>


It automates the adding or removing of blocks of code before our software is compiled. This allows us to easily create different "versions" or "builds" of our program.


<Feedback>


Correct! This encapsulates the essence of conditional inclusion using preprocessor directives.


</Feedback>


</Answer>


<Answer>


They are a safer alternative to `if` statements, for scenarios where we don't care as much about performance.


<Feedback>


Conditional inclusion does not cover the same use case as `if` statements.


Preprocessor directives are evaluated at build time, ie, before we create our executable


`if` statements are evaluated at run time, ie, when a user runs our executable


</Feedback>


</Answer>


</Question>


</Quiz>


<Ad />


## The `#define` Directive


As we saw in the previous section, if we want to provide a preprocessor definition across our whole project, we typically do it through our build tools.


But we don't have to - we can just define things within our source files.  For example, we can define a flag like this:


```c++
#define DEVELOPMENT_BUILD
```


In files where this directive exists, the effect is equivalent to having set it through our tooling:


```c++
#define DEVELOPMENT_BUILD//<h>

#include <iostream>
using namespace std;

int main(){
  cout << "Hello There";
#ifdef DEVELOPMENT_BUILD
  cout << "\nThis is a developer build";
#endif
}
```


```c++
//<o>
Hello There
This is a developer build
```


Some things to note about `#define` are:

- The things we define with this directive are typically called "macros" - eg, `DEVELOPMENT_BUILD` is a macro
- To distinguish macros from other C++ code, we typically use all uppercase names with `_` as a separator
- We do **not** end macros with a semi-colon - they are not C++ statements
- Macros are typically defined at or near the top of files.  A macro is available from the line it was defined until the end of the file.

<Quiz title="Macro Definitions">


<Question>


How can we define a macro called `IS_DEMO` that we could use with an `#ifdef` directive?


<Answer>


`#macro IS_DEMO`


<Feedback>


Remember, the directive used to define macros follows a specific syntax. Reflect on the standard format for defining macros.


</Feedback>


</Answer>


<Answer isCorrect>


`#define IS_DEMO`


<Feedback>


Correct! This is the standard way to define a macro


</Feedback>


</Answer>


<Answer>


`#bool IS_DEMO`


<Feedback>


Consider the typical directive used for defining macros and how it differs from regular C++ statements.


</Feedback>


</Answer>


</Question>


</Quiz>


## Text Replacement Macros


The utility of macros goes beyond simple boolean defined or not-defined logic.


Text substitution macros allow us to `#define` blocks of code, and then easily insert those blocks of code elsewhere in our project as needed.


The following sections can make people a little nervous, but don't worry.  It's fairly uncommon that we need to create text replacement macros.  As a beginner, we're much more likely to be using these macros than defining them.


So if the following examples are a bit uncomfortable, just treat them as demonstrations of the types of things that are possible with macros.


Below, we create a `DEFINE_INT` macro.  This will replace any instances of `DEFINE_INT` in our file with the code to create an integer variable called `MyInt` with a value of `4`.


```c++
#define DEFINE_INT int MyInt{4};//<h>

#include <iostream>
using namespace std;

struct MyType {
  DEFINE_INT//<h>
};

int main(){
  DEFINE_INT//<h>
  cout << "MyInt: " << MyInt << '\n';

  MyType MyObject;
  cout << "MyObject.MyInt: " << MyObject.MyInt;
}
```


```c++
//<o>
MyInt: 4
MyObject.MyInt: 4
```


Below, we define a macro for defining functions called `Greet()`.  We then use this macro to add a member function to our `MyType` struct, as well as a free function defined above our `main` function.


Preprocessor definitions can span multiple lines by using the `\` character as a line break:


```c++
#define DEFINE_GREET         \//<h>
void Greet(){                \//<h>
  cout << "Hello There\n";   \//<h>
};//<h>

#include <iostream>
using namespace std;

struct MyType {
  DEFINE_GREET//<h>
};

DEFINE_GREET//<h>

int main(){
  Greet();

  MyType MyObject;
  MyObject.Greet();
}
```


```c++
//<o>
Hello There
Hello There
```


## Function-Like Macros


Macros can also accept arguments to use within their replacement text.  This can make them behave somewhat like functions.


The following version of the macro accepts two arguments to be used in the replacement:


```c++
#define DEFINE_GREET(Greeting, Name)      \//<h>
void Greet() {                            \//<h>
  cout << Greeting << ", I am " << Name   \//<h>
    << "\nNice to meet you!\n\n";         \//<h>
};//<h>

#include <iostream>
using namespace std;

struct Goblin {
  DEFINE_GREET("Howdy", "a Goblin object")//<h>
};

DEFINE_GREET("Hi there", "a free function")//<h>

int main(){
  Greet();

  Goblin SomeGoblin;
  SomeGoblin.Greet();
}
```


```c++
//<o>
Hi there, I am a free function
Nice to meet you!

Howdy, I am a Goblin object
Nice to meet you!
```


Again, don't worry if this all looks a little weird.  We're unlikely to need to write code like this as a beginner.  It's more important at this stage to understand what macros are and how to use them.


A common way to identify when you're using a macro is that they tend to have an UPPERCASE_NAME, whilst developers tend to name their regular C++ constructs using either PascalCase or snake_case:


```c++
PROBABLY_A_MACRO("Hello World")
ProbablyAFunction("Hello World");
probably_a_function("Hello World");
```


For example, Unreal Engine provides a lot of utilities in the form of macros.  Logging to the terminal in that ecosystem is done using two function-like macros, `UE_LOG` and `TEXT`, alongside regular C++ symbols such as `LogTemp` and `Error`:


```c++
UE_LOG(LogTemp, Error, TEXT("Hello!"))
```


## Summary


In this lesson, we've explored the essentials of the preprocessor. We covered:

- **Preprocessor Role**: Explored the preprocessor's function in preparing code for compilation.
- **Conditional Inclusion**: Covered the use of `#ifdef`, `#ifndef`, and related directives for compiling code conditionally.
- **Macro Definitions**: Discussed defining and using macros to simplify repetitive tasks and code management.
- **Text Replacement and Function-Like Macros**: Introduced advanced macro uses, used for text replacement within our code.

<Preview>


### The `#include` directive


Aside from conditional inclusion, the other main preprocessor directive we use is `#include`.


This allows us to import code from other places into our files, like we've been doing with `#include <iostream>`.


In the next lesson, we'll cover how the `#include` directive works, and how we can make full use of it.


</Preview>

Expanded Setting Preprocessor Definitions section

Fixed typo in code example and made minor style improvements

Preprocessor directives in C++

Preprocessor

Conditional inclusion

Preprocessor directives

{CPP}The C++ Preprocessor - Learn to define macros for conditional inclusion and text replacement

Preprocessor Definitions

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming