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're initializing a variable with a value, the compiler can automatically infer the type our variable should have.  We can ask the compiler to infer this using the `auto` keyword.


Below, we're initializing `MyNumber` using an `int` literal, so the compiler will set `MyNumber`'s type to `int`:


```c++
// This will create an int
auto MyNumber { 5 };
```


</Excerpt>


Most editors, including Visual Studio, will let us inspect what the type was deduced to be by hovering over the variable name.


<Img file="Capture.png" width="351" height="83" alt="Screenshot showing Visual Studio deducing an type declared as auto" blurHash="L37BM~584nnO4:?wxvMx00%L%MWV" />


Types can also automatically be deduced in a variety of contexts.  For example, when initializing a variable using an expression, such as a function call, its type can also be deduced from the return type of that expression.


Below, `GetFloat()`'s return type is `float`, so `MyNumber` will have a type of `float`:


```c++
float GetFloat() {
  return 3.14;
}

// Will be float
auto MyNumber { GetFloat() };
```


<Ad />


## Dynamic Typing vs `auto`


Some may have experience with other programming languages that have a dynamic type system.  There, the type of a variable can be changed during our program's execution.  The following example is valid JavaScript:


```c++
var MyVariable = 10;
MyVariable = "Hello World";
```


It is important to note that `auto` is _**not**_ an implementation of dynamic types.  `auto` will fix the variable type as soon as it is created.  Then, any future assignment will try to convert the new value to that type.


Below, we create an `int` variable, and then try to update it by converting the new value to that same type.  In this case, the conversion is impossible, so we get a compilation error:


```c++
auto MyVariable { 10 };
MyVariable = "Hello World";//<e>
```


```c++
//<o>
error: cannot convert from 'const char [12]' to 'int'
```


For the same reason, we also can't do this:


```c++
auto MyVariable;//<e>
```


```c++
//<o>
error: 'MyVariable': a symbol whose type contains 'auto' must have an initializer
```


If we try to use `auto` without providing an initial value, the compiler cannot infer what to set its type to.


C++ does support dynamic typing, and we cover it in the advanced course.  However, C++ has a strong type system, and it's generally designed such that code written in C++ will be using that type system heavily.


## Function Return Types Using `auto`


The `auto` keyword can also be used to automatically determine the return type of a function.  This can be inferred by how the function uses the `return` statement.


Below, `GetDouble()` will have its return type correctly deduced to `double`., as we're `return`ing a `double` literal.


Because of this, `MyNumber` will also have its return type inferred as a `double`:


```c++
auto GetDouble() {
  return 3.14;
}

auto MyNumber { GetDouble() };
```


This depends on all of our `return` statements deducing to the same type.  The following will not work, as the compiler cannot determine whether the return type should be `float` or `double`:


```c++
auto GetDouble() {
  if (SomeCondition) {
    return 9.8f;
  }
  return 3.14;//<e>
}
```


```c++
//<o>
error: 'double': all return expressions must deduce to the same type: previously it was 'float'
```


If we convert all return types to a consistent type, our code will compile again.  In the following example, the return type of `GetDouble` will correctly be inferred as `double`:


```c++
auto GetDouble() {
  if (SomeCondition) {
    return static_cast<double>(9.8f);//<h>
  }
  return 3.14;
}
```


Were we to specify the return type, the compiler would implicitly convert the returned values to that type, as we've seen before.


Below, our code will compile, with our function returning a `double` with the value of `9.8` if `SomeCondition` is true:


```c++
double GetDouble() {
  if (SomeCondition) {
    return 9.8f;
  }
  return 3.14;
}
```


## Function Paramaters With `auto` (C++20)


As of C++20, `auto` can also be used with function parameters:


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

auto NumberA { Add(1, 2) };
auto NumberB { Add(1, 2.0) };
```


We're calling the `Add()` function with two integers, so `x` and `y` in that function will have the `int` type.


Then, we return the result of summing two `int` objects, therefore the return type of `Add()` will also be deduced to be an `int`.


Finally, because `NumberA` is being initialized with an expression that returns an `int`, its type will also be an `int`.


The same process applies to `NumberB`, which will have a type of `double`.


<Aside>


### Function Templates


There is some additional nuance when our functions have `auto` parameters.  In the previous example, we're technically not defining a function at all - we're defining a _**function template**_.


The compiler can use function templates to automatically create functions at compile time, based on how we use that template through the rest of our code.


In this case, we're using the template with two unique argument lists - `(int, int)` and `(int, double)`.  As such, the compiler will generate two functions - one with the prototype `int Add(int, int)` and a second with the prototype `double Add(int, double)`


We explore templates in more detail in our advanced course.


</Aside>


<Ad />


## Qualifiers: `auto` Pointers, `auto` References


As with any type, we can add qualifiers to our `auto` declarations.  For example, we can create references and pointers to automatically deduced types:


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

// Reference to an automatically deduced type
auto& ReferenceToX { x };

// Pointer to an automatically deduced type
auto* PointerToX { &x };
```


## Should We Use `auto`?


Generally, we should only use `auto` if it makes our code clearer.  The main scenario where this is the case is where it reduces unnecessary noise.


Typically this involves scenarios where we're repeating a complex type multiple times within the same expression:


```c++
SomeNamespace::SomeType MyObject {
  static_cast<SomeNamespace::SomeType>(Target)
};
```


Adding `auto` here will reduce the noise, and not hide the type as we're already specifying it in the `static_cast` parameter anyway:


```c++
auto MyObject {
  static_cast<SomeNamespace::SomeType>(Target)
};
```


Whilst it can save a few keystrokes, using `auto` can make our code more difficult to read, especially as it gets more complicated.  


Generally, `auto` should _**not**_ be used if our only reason is to avoid some keystrokes.  In the future, we'll see more and more complex types.  If our type is verbose and repeated often in our file, we can be tempted to use `auto`.


But we should consider a type alias instead.  After adding the following `using` statement, we can refer to our type simply as `Party`, rather than being tempted to use `auto`:


```c++
using Party =
  std::vector<std::pair<Character*, bool>>;

Party MyParty{ GetParty() };
```


There are two main problems with `auto`:


### Determining the Type Requires Tool Assistance


We've seen how in most IDEs, we can easily hover over a type to determine its type, even if the code is using `auto`.  However, hovering is still slower than reading, and code isn't always opened in an IDE.


In larger projects, code is often read in tools that don't provide the functionality of IDEs.  A common example is source control applications such as GitHub.


### Determining the Type Requires our Code be Compilable


Secondly, even if our editors can show us how `auto` is being interpreted, that capability often requires our code to be in a compilable state.


If we introduce an issue that prevents code from being compilable, we often lose visibility on the types we were relying on being deduced by the compiler.  This can make the issue even more difficult to debug.


In the remainder of this course and future courses, we adopt a fairly conservative use of `auto`.  We avoid it by default but will use it if we think it makes the code clearer.


This generally falls in line with Google's style guide:


<Quote author="Google C++ Style Guide" url="https://google.github.io/styleguide/cppguide.html">
Use type deduction only to make the code clearer or safer, and do not use it merely to avoid the inconvenience of writing an explicit type.


When judging whether the code is clearer, keep in mind that your readers are not necessarily on your team, or familiar with your project, so types that you experience as unnecessary clutter will very often provide useful information to others
</Quote>


However, many others recommend avoiding `auto` as much as possible:


<Quote author="Unreal Engine Coding Standard" url="https://docs.unrealengine.com/5.3/en-US/epic-cplusplus-coding-standard-for-unreal-engine/">


Always be explicit about the type you're initializing. This means that the type must be plainly visible to the reader.


...


It's very important that types are clearly visible to someone who is reading the code. Even though some IDEs are able to infer the type, doing so relies on the code being in a compilable state. It also won't assist users of merge/diff tools, or when viewing individual source files in isolation, such as on GitHub.
</Quote>


## Summary


This lesson introduced the concept of automatic type deduction, explaining how the `auto` keyword enables the compiler to infer variable types. The key topics points included:

- The `auto` keyword allows the compiler to deduce the type of a variable from its initializer.
- `auto` is distinct from dynamic typing found in languages like JavaScript; once a type is deduced, it cannot be changed.
- The lesson explains how `auto` can be used for function return types and function parameters.
- It discusses the use of `auto` in creating function templates, where the compiler generates functions based on the template's usage.
- We should use `auto` sparingly and only to improve clarity and readability, not simply convenience.

<Preview>


### Constants and `const`


In the next lesson, we will explore constants and const-correctness. This lesson will cover the importance of immutability in programming, teaching you how to effectively use `const` to enhance the safety and clarity of your code.


We will also discuss best practices for const-correctness in various programming scenarios.  Key topics covered in this lesson will include:

- Understanding the concept of constants and their role in programming.
- The use of the `const` keyword with variables, functions, and pointers.
- Techniques for implementing const-correctness in code to prevent unintended modifications.
- Best practices and common pitfalls in using `const` in programming.

</Preview>

Fixed typo and improved examples for `auto` return types

auto - cppreference.com

Type Inference in C++ - Wikipedia

auto (C++) | Microsoft Docs

{CPP}Learn how to use the auto keyword in C++ for easier type deduction. This lesson is ideal for beginners

{CPP}Understanding "auto" in C++: A Beginner's Guide

Qualifiers: `auto` Pointers, `auto` References

Determining the Type Requires Tool Assistance

Determining the Type Requires our Code be Compilable

Automatic Type Deduction using `auto`

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Automatic Type Deduction using auto

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Automatic Type Deduction using `auto`