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>


So far, we've been working under the restrictions that functions must be declared before they are used.  For example, we've been unable to create code like shown below:


```c++
int main() {
  // Add is not defined yet
  Add(1, 2);//<e>
}

int Add(int x, int y) {
  return x + y;
}
```


```c++
//<o>
Error: 'Add': identifier not found
```


Because the compiler reads our files top-to-bottom, when it reaches line 3, it encounters a call to a function that it's not aware of.


The easy solution we've been using has been to move `Add` above `main`.  However, we may not want to do this for stylistic reasons.


Worse, not all problems in this category can be solved by just moving functions around.


</Excerpt>


## Circular Dependencies


Circular dependencies occur when two or more parts of our code reference each other in a cycle.


With functions, it might look something like this:


```c++
void HandlePositive(int x) {
  if (x < 0) HandleNegative(x);
}

void HandleNegative(int x){
  if (x >= 0) HandlePositive(x);
}
```


Here, `HandlePositive` calls `HandleNegative` and vice versa, creating a circular dependency.


This dependency cannot be resolved by merely reordering the functions, as each function requires the other to be declared beforehand.


The primary method C++ provides to let us solve circular dependencies is the ability to separate the _**declaration**_ and _**definition**_ of our function.  This means we can _**declare**_ a function in one region of code, but _**define**_ it elsewhere.


We can think of a declaration as a minimalist description of our function, whilst the definition is the complete implementation.


For code to use our function, it only needs to be declared at the point of use - not fully defined.  The full definition can come later in the file or, in larger projects, in a different file entirely.


Taking advantage of this mechanism is referred to as _**forward declaring**_ the function.


<Preview>


### The Compiler and the Linker


In C++, the compilation process is broken down into two processes - first our files are _**compiled**_, and then they are _**linked**_.


The compiler reads each of our source files from top to bottom.  Each file generates an intermediate output, sometimes referred to as a translation unit.


The linker then takes these translation units and links them together to create a single cohesive package


A forward declaration is a promise to the compiler that the thing we're trying to use is going to be defined somewhere else.  We're telling the compiler that the linker will take care of it.


We'll discuss how our code gets built in more detail later in the course.


</Preview>


<Ad />


## Function Prototypes


To forward declare a function, we first need to understand what a function **prototype** is.  This is sometimes also called the **signature**.


We can think of the prototype as just the heading of the function, without its body.  For example, if we have the following `Add` function:


```c++
int Add(int x, int y) {
  return x + y;
}
```


Its prototype would be this:


```c++
int Add(int x, int y);
```


So, the prototype is the function's return type, the function name, and the parameter types.


In this example, the return type is `int`, the name is `Add`, and the parameter types are `int, int`


Within the function prototype, the names of our parameters are optional.  They are typically worth including anyway for the benefit of anyone reading our code.


If the names are descriptive, including them helps anyone reading our prototype get a better understanding of how our function works.


But technically, only the types are required, so the following is also a valid prototype for our function:


```c++
int Add(int, int);
```


<Quiz title="Function Prototype">


<Question>


What is a function prototype?


<Answer>


The body of the function - everything between `{` and `}`.


<Feedback>


Recall that a function prototype is about declaring, not defining. Think about what we need to tell the compiler about a function without providing its full implementation.


</Feedback>


</Answer>


<Answer isCorrect>


The name, return type, and parameter types of the function.


<Feedback>


You got it!  A function prototype includes the function's name, return type, and parameter types, providing a minimal declaration for the compiler.


</Feedback>


</Answer>


<Answer>


The specific scope in which the function is defined.


<Feedback>


This answer focuses on where the function is defined, but remember what a prototype specifically describes about a function.


</Feedback>


</Answer>


</Question>


<Question>


What is a valid prototype for this function?


```c++
float Calculate(int x, float y) {
  return x * y;
}
```


<Answer>


This function cannot have a prototype


<Feedback>


Every function can have a prototype. Consider what basic elements define the function's interface to the rest of the program.


</Feedback>


</Answer>


<Answer isCorrect>


`float Calculate(int x, float y);`


<Feedback>


Exactly right! This is the correct prototype, summarizing the function's interface without its implementation details.


</Feedback>


</Answer>


<Answer>


`Calculate { int, float => float };`


<Feedback>


This format isn't how we typically represent a prototype in C++. Focus on the conventional syntax for function prototypes.


</Feedback>


</Answer>


<Answer>


`Calculate<int, float> { float };`


<Feedback>


Remember the standard format of a C++ function prototype.


</Feedback>


</Answer>


</Question>


</Quiz>


### Semicolons with Function Declarations


Earlier, we saw how a function definition does **not** need a semicolon:


```c++
// Function Definition
void SomeFunction(
  int SomeInt, bool SomeBool, float SomeFloat
) {

} // No semicolon needed //<h>
```


However, a function declaration **does** require one:


```c++
// Function Declaration
void SomeFunction(
  int SomeInt, bool SomeBool, float SomeFloat
); // Semicolon required //<h>
```


<Definition>


### Application Programming Interfaces and APIs


Function prototypes relate closely to the software design concept of an _**application programming interface**_, or API.


When we write code that calls a function, we are using that function's API.  The API of a function is everything that the caller needs to know to use that function.


This is exactly the same information that is in the prototype:

- the function's name
- the type of data they need to provide as arguments
- the type of data the function will return to them

The function body is not part of the API because the callers don't interact with the body at all, and shouldn't need to know what's in there.  This distinction becomes more important when working on larger projects.


The body of a complex function can have hundreds of lines of code, and a complex program can have thousands of such functions.  We can't understand all of it, but we don't need to.


We just need to understand the much simpler API of whatever we're trying to use, and trust that the code behind the scenes (such as the body of the function we're calling) works as it should.


</Definition>


<Ad />


## Using Forward Declaration


Now, we no longer have to _**define**_ our function before we use it - we just have to _**declare**_ it, using its prototype.


Forward declarations are typically put near the top of the files that use them, but as long as they're provided before the functions are used, our code will work as expected:


```c++
int Add(int x, int y);//<h>

int main() {
  Add(1, 2);
}

int Add(int x, int y) {
  return x + y;
}
```


<Quiz title="Forward Declarations">


<Question>


After running the code below, what is the value of `x` inside the `main` function?


```c++
int main() {
  int x { Calculate() };
}

int Calculate() {
  return 10 * 10;
}
```


<Answer>


The integer `0`


<Feedback>


Consider the order of function declaration and definition in this code. Does the compiler know about `Calculate` when it's called?


</Feedback>


</Answer>


<Answer >


The integer `100`


<Feedback>


Look closely at where `Calculate` is defined in relation to where it is called. What rule about function declarations might this violate?


</Feedback>


</Answer>


<Answer isCorrect>


This is invalid code


<Feedback>


Correct. The function `Calculate` needs to be declared before `main` for the compiler to recognize it.


</Feedback>


</Answer>


</Question>


<Question>


After running the code below, what is the value of `x` inside the `main` function?


```c++
int Calculate();

int main() {
  int x { Calculate() };
}

int Calculate() {
  return 10 * 10;
}
```


<Answer>


The integer `0`


<Feedback>


Remember how forward declarations work. If `Calculate` is declared before use, what should its behavior be?


</Feedback>


</Answer>


<Answer isCorrect>


The integer `100`


<Feedback>


Correct! The forward declaration of `Calculate` ensures that the compiler is aware of it when it's called in **`main`**.


</Feedback>


</Answer>


<Answer>


This is invalid code


<Feedback>


Given that `Calculate` is forward declared, consider how this affects its usage in the `main` function.


</Feedback>


</Answer>


</Question>


</Quiz>


<Aside>


### Definitions, Declarations, and Prototypes


It's worth highlighting a relationship between declarations and definitions that may not be immediately obvious:

- Function definitions _**are also**_ function declarations
- Function declarations _**may or may not**_ be function definitions
- A function prototype is a _**declaration without a definition**_

The code below is a function declaration and definition, but not a prototype:


```c++
int Calculate() {
  return 10 * 10;
}
```


Whilst this code is a declaration and prototype, but not a definition:


```c++
int Calculate();
```


</Aside>


This separation between _declaring_ a function and _defining_ it is likely to feel quite strange, especially at this stage.


However, this is a very important concept.  Most C++ code is created this way.  This is because the separation can have some major workflow benefits for larger projects that span many files.  We'll see examples of this soon.


## Summary


In this lesson, we've explored several key concepts regarding forward declarations in C++:

- The necessity of forward declarations when functions are used before their definitions.
- Understanding circular dependencies and their resolution using forward declarations.
- The distinction between declaring and defining functions.
- How function prototypes work, including their syntax and purpose.
- Practical application of forward declarations in code, demonstrating how they enable flexible ordering of function definitions.

This knowledge not only helps in writing more organized and maintainable code but also lays the groundwork for understanding more complex patterns we'll see later in the course.


<Preview>


### Loops


In the upcoming lesson, we will introduce one of the most fundamental constructs of programming: loops. Here's a sneak peek at what we'll cover:

- Introduction to loops, allowing us to repeat blocks of code whilst some condition is `true`.
- Exploration of different types of loops: `for` loops, `while` loops, and `do-while` loops.
- Understanding loop control statements, including `break` and `continue`.
- Practical examples and exercises to illustrate the usage of loops in various scenarios.
- Tips on avoiding common pitfalls such as infinite loops.

</Preview>

Fixed grammar error and updated references

Added note on semicolons after function declarations

Forward declaration

Forward declarations

What are forward declarations in C++?

{CPP}Explore forward declarations in C++: A beginner's tutorial on managing function ordering

{CPP}Beginner's Guide to Forward Declarations in C++

Application Programming Interfaces and APIs

Definitions, Declarations, and Prototypes

Forward Declarations

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming