A quick crash tour of C++ basics, for those with previous object oriented programming experience.

Learn the fundamentals of C++ programming: declaring variables, using built-in data types, and performing operations with operators

Variables, Types and Operators

Learn the basics f writing and using functions in C++, including syntax, parameters, return types, and scope rules.

Introduction to Functions

A quick introduction to namespaces in C++, alongside the standard library and how we can access it

Namespaces, Includes, and the Standard Library

Learn the fundamentals of controlling program flow in C++ using if statements, for loops, while loops, continue, and break

Conditionals and Loops

A crash tour on how we can create custom types in C++ using classes, structs and enums

Classes, Structs and Enums

Learn the fundamentals of the C++ build process, including the roles of the preprocessor, compiler, and linker.

Preprocessor Directives and the Build Process

Learn the fundamentals of references, pointers, and the `const` keyword in C++ programming.

Understanding Reference and Pointer Types

Discover operator overloading, allowing us to define custom behavior for operators when used with our custom types

Operator Overloading

Learn how to write flexible and extensible C++ code using polymorphism, virtual functions, and dynamic casting

Run-time Polymorphism

A quick tour of ten useful techniques in C++, covering dates, randomness, attributes and more

Odds and Ends: 10 Useful Techniques

Whirlwind Tour of C++ Basics

A deeper look at how memory is managed in C++, and how we can take control of that process to keep larger projects maintainable.

Learn about stack allocation, limitations, and transitioning to the Free Store

Memory Management and the Stack

Learn about dynamic memory in C++, and how to allocate objects to it using `new` and `delete`

Dynamic Memory and the Free Store

An introduction to memory ownership using smart pointers and `std::unique_ptr` in C++

Smart Pointers and `std::unique_ptr`

An introduction to shared memory ownership using `std::shared_ptr`

Shared Pointers using `std::shared_ptr`

A full guide to weak pointers, using `std::weak_ptr`.  Learn what they're for, and how we can use them with practical examples

Weak Pointers with `std::weak_ptr`

Learn how to control exactly how our objects get copied, and take advantage of copy elision and return value optimization (RVO)

Copy Semantics and Return Value Optimization

Learn how we can improve the performance of our types using move constructors, move assignment operators and `std::move()`

Move Semantics

A straightforward guide to l-values and r-values, aimed at helping you understand the fundamentals

Value Categories (L-Values and R-Values)

Memory Management

An introduction to metaprogramming using templates, allowing us generate classes and functions at compile time.

Learn how to use type aliases and utilities to simplify working with complex types.

Type Aliases

Learn to use `decltype` and `std::declval` to determine the type of an expression at compile time.

Type Deduction Using `decltype` and `declval`

Learn how templates can be used to create multiple classes from a single blueprint

Class Templates

Learn how to separate class templates into declarations and definitions while avoiding common linker errors

Templates and Header Files

Learn how to implement functionality at compile-time using `constexpr` and `consteval`

Compile-Time Evaluation

An introduction to variable templates, allowing us to create variables at compile time.

Variable Templates

Understand the fundamentals of C++ function templates and harness generics for more modular, adaptable code.

Function Templates

Learn how to create and use member function templates in classes and structs, including syntax, instantiation, and advanced techniques

Member Function Templates

A practical guide to template specialization in C++ covering full and partial specialization, and the scenarios where they're useful

Template Specialization

Templates

Learn advanced compile-time techniques covering overload resolution, type traits and C++20 concepts

Learn how the compiler decides which function to call based on the arguments we provide.

Understanding Overload Resolution

Learn how to use type traits to perform compile-time type analysis, enable conditional compilation, and enforce type requirements in templates.

Type Traits: Compile-Time Type Analysis

Learn how SFINAE allows templates to remove themselves from overload resolution based on their arguments, and apply it in practical examples.

Using SFINAE to Control Overload Resolution

Learn how to use C++20 concepts to constrain template parameters, improve error messages, and enhance code readability.

Concepts in C++20

Learn how to create your own C++20 concepts to define precise requirements for types, using boolean expressions and `requires` statements.

Creating Custom Concepts

Learn how to use concepts to express constraints on classes, ensuring they have particular members, methods, and operators. 

Using Concepts with Classes

Learn to identify and react to object types at runtime using RTTI, dynamic casting and the `typeid()` operator

Run Time Type Information (RTTI) and `typeid()`

Type Traits and Concepts

Explore a deeper and more organised way of detecting and handling errors, which lets us keep larger projects maintainable

Learn how we can ensure that our application is in a valid state using compile-time and run-time assertions.

Errors and Assertions

This lesson provides an introduction to exceptions, detailing the use of `throw`, `try`, and `catch`.

Exceptions: `throw`, `try` and `catch`

Gain a thorough understanding of exception types, including how to throw and catch both standard library and custom exceptions in your code

Exception Types

This lesson explores the `std::terminate()` function and `noexcept` specifier, with particular focus on their interactions with move semantics.

Using `std::terminate()` and the `noexcept` Specifier

This lesson offers a comprehensive guide to storing and rethrowing exceptions

Storing and Rethrowing Exceptions

Learn about nested exceptions in C++: from basic concepts to advanced handling techniques

Nested Exceptions

Learn about Function Try Blocks, and their importance in managing exceptions in constructors

Function Try Blocks

Learn how to handle errors as values in C++23 using the `std::expected` type

Errors as Values and `std::expected`

Errors and Exceptions

A detailed guide to arrays and linked lists in C++, which allow us to place collections of our objects into sequential containers

An introduction to static arrays using `std::array` - an object that can store a collection of other objects

Static Arrays using `std::array`

A detailed guide to working with classic C-style arrays within C++, and why we should avoid them where possible

C-Style Arrays

A detailed guide to creating a "view" of an array using `std::span`, and why we would want to

Array Spans and `std::span`

A guide to `std::mdspan`, allowing us to interact with arrays as if they have multiple dimensions

Multidimensional Arrays and `std::mdspan`

An introduction to algorithms - the foundations of computer science.  Learn how to design, analyze, and compare them.

Algorithm Analysis and Big O Notation

This lesson introduces the concept of data structures beyond arrays, and why we may want to use alternatives.

Data Structures and Algorithms

This lesson provides an in-depth look at iterators in C++, covering different types like forward, bidirectional, and random access iterators, and their practical uses.

Iterators

This lesson provides an in-depth exploration of `std::forward_list`, covering creation, management, and advanced list operations

Linked Lists using `std::forward_list`

Arrays and Linked Lists

An introduction to hash-based data structures - containers that allow us to efficiently find specific objects by value

This lesson provides an in-depth look at hashing in C++, including `std::hash`, collision strategies, and usage in hash-based containers.

Hashing and `std::hash`

This lesson provides a thorough understanding of `std::unordered_set`, from basic initialization to handling custom types and collisions

Hash Sets using `std::unordered_set`

Master the use of `std::pair` with this comprehensive guide, encompassing everything from simple pair manipulation to template-based applications

Using `std::pair`

Creating hash maps using the standard library's `std::unordered_map` container

Hash Maps using `std::unordered_map`

Hash Sets and Hash Maps

Learn some of the many other choices we have for organising collections of objects, and the advantages and disadvantages of each option.

A comprehensive guide to using `std::optional` to represent values that may or may not be present.

Nullable Values, `std::optional` and Monadic Operations

Learn how to store dynamic data types in C++ using unions and the type-safe `std::variant`

Constrained Dynamic Types using Unions and `std::variant`

Learn how to use void pointers and `std::any` to implement unconstrained dynamic types, and understand when they should be used

Unconstrained Dynamic Types using Void Pointers and `std::any`

A guide to tuples and the `std::tuple` container, allowing us to store objects of different types.

Tuples and `std::tuple`

Learn the fundamentals and applications of queues with the `std::queue` container.

Introduction to Queues and `std::queue`

Learn how to access objects based on their importance, and how to customise how that priority is determined

Priority Queues using `std::priority_queue`

An introduction to the stack data structure, and the standard library implementation - `std::stack`

Introduction to Stacks using `std::stack`

A guide to double-ended queues - a structure that behaves like a vector, specialised for manipulating objects at the edges of the collection

Double-Ended Queues using `std::deque`

Standard Library Data Structures

A deeper look at C++ functions, and more advanced techniques of how we can create and use them.

Learn about first-class functions in C++: a feature that lets you store functions in variables, pass them to other functions, and return them, opening up new design possibilities

First Class Functions

Learn about function pointers: what they are, how to declare them, and their use in making our code more flexible

Function Pointers

This lesson introduces function objects, or functors.  This concept allows us to create objects that can be used as functions, including state management and parameter handling.

Function Objects (Functors)

An introduction to lambda expressions - a concise way of defining simple, ad-hoc functions

Lambdas

A comprehensive overview of function helpers in the standard library, including `std::invocable`, `std::predicate` and `std::function`.

Standard Library Function Helpers

Learn how to create pointers to class functions and data members, and how to use them

Pointers to Members

This lesson covers function binding and partial application using `std::bind()`, `std::bind_front()`, `std::bind_back()` and `std::placeholders`.

Function Binding and Partial Application

An alternative syntax for defining function templates, which allows the return type to be based on their parameter types

Trailing Return Types

An introduction to recursive functions, their use cases, and how to optimize their performance

Recursion and Memoization

An introduction to variadic functions, which allow us to pass a variable quantity of arguments

Variadic Functions

An introduction to C++17 fold expressions, which allow us to work more efficiently with parameter packs

Fold Expression

An introduction to problems that can arise when our functions forward their parameters to other functions, and how we can solve those problems with `std::forward`

Perfect Forwarding and `std::forward`

Working with Functions

Expanding on our knowledge of iterators, and introducing C++20 ranges, allowing us to create more flexible containers and algorithms

This lesson offers an in-depth look at iterators and ranges, emphasizing their roles in container traversal

Iterators and Ranges

Learn to implement iterators in custom types, and make them compatible with range-based techniques.

Implementing Ranges for Custom Types

An alternative way of defining ranges, and why we sometimes need to use them

Defining Ranges using Sentinels

A detailed guide to implementing a custom iterator type from scratch, using modern recommended techniques

Creating Custom Iterators using C++20 Concepts

An introduction to iterator and range-based algorithms, using examples from the standard library

Iterator and Range-Based Algorithms

Learn how to use projection functions to apply range-based algorithms on derived data

Projection Functions

Learn how to create and use views in C++ using examples from `std::views`

Standard Library Views

This lesson introduces std::ranges::subrange, allowing us to create non-owning ranges that view some underlying container

Creating Views using `std::ranges::subrange`

An introduction to 8 more useful algorithms from the standard library, and how we can use them alongside views, projections, and other techniques

8 Key Standard Library Algorithms

Multithreading in C++ standard library algorithms using execution policies

Parallel Algorithm Execution

An overview of the most useful algorithms that are available within the standard library

An introduction to the 8 main searching algorithms in the C++ standard library, including `find()`, `find_if()`, `find_if_not()`, `find_first_of()`, `adjacent_find()`, `search_n()`, `search()`, and `find_end()`.

Search Algorithms

An introduction to the advantages of binary search, and how to use it with the C++ standard library algorithms `binary_search()`, `lower_bound()`, `upper_bound()`, and `equal_range()`

Binary Search in C++

An introduction to the 5 main counting algorithms in the C++ standard library:  `count()`, `count_if()`, `any_of()`, `none_of()`, and `all_of()`

Counting Algorithms

An introduction to the seven minimum and maximum algorithms in the C++ standard library: `clamp()`, `min()`, `min_element()`, `max()`, `max_element()`, `minmax()`, and `minmax_element()`.

Minimum and Maximum Algorithms

An introduction to the seven movement algorithms in the C++ standard library: `move()`, `move_backward()`, `rotate()`, `reverse()`, `shuffle()`, `shift_left()`, and `shift_right()`.

Movement Algorithms

An introduction to the 7 copying algorithms in the C++ standard library: `copy()`, `copy_n()`, `copy_if()`, `copy_backward()`, `reverse_copy()`, `rotate_copy()`, and `unique_copy()`.

Copying Algorithms

An overview of the key C++ standard library algorithms for removing objects from containers.  We cover `remove()`, `remove_if()`, `remove_copy()`, and `remove_copy_if()`.

Removal Algorithms

Standard Library Algorithms

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

User Defined Conversions

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Professional C++

Questions & Answers