Learn C++

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

An introduction to partitions, and the C++ standard library algorithms that create them

An introduction to the 8 main comparison algorithms in the C++ standard library

An overview of how to create variables that can store any date type, using void pointers and std::any

An introduction to the 6 new folding algorithms added in C++23, providing alternatives to std::reduce and std::accumulate

A detailed guide to generating a single object from collections using the std::reduce and std::accumulate algorithms

A practical guide to defining ranges using sentinel values, and why we sometimes need to

A quick guide to creating objects using lists, including std::initializer_list, aggregate and designated initialization

A guide to storing one of several different data types within the same container, using unions and variants

A practical introduction to string views, and why they should be the main way we pass strings to functions

An in-depth guide to std::string_view, including their methods, operators, and how to use them with standard library algorithms

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

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

A detailed introduction to double-ended queues using std::deque, and how they compare to std::vector

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

An introduction to set algorithms, and how to implement them using the C++ standard library

Solving problems that arise when our functions forward their arguments to other functions

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

A guide to handling optional data in C++ using the std::optional container

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

A guide to creating and using functions that can have a variable number of parameters

A guide to tuples in C++, using the std::tuple container. Tuples allow us to store any number of objects, and those objects can have different types.

An introduction to the mutable keyword, which gives us more flexibility when working with const objects.

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

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

An introduction to arrays in C++ using std::array - an object that can store a collection of other objects

A detailed guide to working with classic C-style arrays within C++, and their many problems

A guide to simplifying our comparison operators using automatic expression rewriting, and the new spaceship operator added in C++20

A practical guide to user-defined literals in C++, which allow us to write more descriptive and expressive values

A guide to how our classes can derive from multiple ancestors in C++, including the common problems and how to solve them

An introduction to the friend keyword, which allows classes to give other objects and functions enhanced access to its members

An overview of the fundamental true or false data type, how we can create them, and how we can combine them.

Make our classes easier to use and less prone to bugs: an introduction to encapsulation

An introduction to function pointers, which allow us to store functions in variables, and pass them around like any other data type

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

A deeper look at the C++ linker, how it interacts with our variables and functions, and how we can control it using the extern and inline keywords

A quick guide to functions in C++, and how global and local scopes interact

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

A quick introduction to conditionals and loops in C++, and how we can use them to control how our program executes

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

A quick guide to the build process in C++, and how we can use preprocessor directives to modify what gets compiled.

Learn the difference between values, references and pointers in C++

A guide on how we can empower our custom types with their own operators, allowing them to be interacted with in a more expressive way

An introduction to polymorphism works in C++, and how we can set up our custom types to take advantage of it

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

Learn an alternative way to write conditionals, which is often used when we want to take different paths based on a specific value

Learn about a special type of function we can add to our classes, which we can use to control how our objects get created.

An introduction to the main built-in types in C++, alongside how to create objects of those types and apply operators to them

A guide to sharing values between objects using static class variables and functions

A practical guide covering the most useful methods and operators for working with std::string objects and their memory

A detailed guide to std::string, covering the most essential methods and operators

A guide to working with and manipulating C-style strings, using the cstring header file

An introduction to C++ character types, the Unicode standard, character encoding, and C-style strings

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

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

A full guide to the concepts feature added in C++20. Learn how we can improve and document our templates with practical examples

A detailed and practical tutorial for type traits in modern C++ covering how we can use them, and examples of the most common use cases

An introduction to regular expression capture groups, and how to use them in C++ with regex search, replace, iterator, and token_iterator

A detailed and practical tutorial for binary serialization in modern C++ using the cereal library.

A detailed and practical tutorial for working with HTTP in modern C++ using the cpr library.

An introduction to C++ package managers, and a step-by-step guide to installing vcpkg on Windows and Visual Studio

A practical guide to working with the JSON data format in C++ using the popular nlohmann::json library.

A detailed guide to reading and writing files in C++ using the standard library’s fstream objects.

A detailed introduction to using the filesystem in C++. Create, delete, move, and navigate through directories and files using the std::filesystem library.

A detailed introduction to C++ Input Streams using cin and istringstream. Starting from the basics and progressing up to advanced use cases including creating collections of custom objects from our streams.

A detailed guide to C++ String Streams using the standard library stringstream. Covers basic use cases, stream position seeking and open modes.

Master priority queues with a complete guide, starting from the basics, using the standard library’s priority_queue.

A detailed overview of C++ Output Streams, from basics and key functions, to error handling and custom types.

A detailed overview of C++20 modules - the modern alternative to #include directives. We cover import and export statements, partitions, submodules, how to combine modules with legacy code, and more.

Learn the many applications of queues in programming. Then see how we can create and use them in C++ using the standard library's std::queue

Learn the advantages and restrictions of Binary Search, and then implement it using the two main C++ standard library algorithms: binary_search and lower_range

An overview of the key C++ standard library algorithms for replacing and removing objects in our containers. We cover replace, replace_if, replace_copy, replace_copy_if, remove, remove_if, remove_copy, and remove_copy_if.

An introduction to regular expressions, and how to use them in C++ with the standard library's regex, regex_match, and regex_search

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

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

Learn how to implement move semantics in C++, the difference between lvalues and rvalues, and what std::move really does.

Learn how to implement copy semantics in C++, and take advantage of copy elision and return value optimization (RVO)

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.

An introduction to the 7 min/max algorithms in the C++ standard library: clamp, min, min_element, max, max_element, minmax, and minmax_element. 

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

Learn how to use projections with standard library algorithms in C++

Learn how to efficiently work with collections of objects using range-based algorithms in C++

An introduction to class templates in C++, explaining why we need them and how to create them

An introduction to shared memory ownership using std::shared_ptr

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

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

An introduction to memory management within C++, starting with stack-allocated memory.

An introduction to C++ variable templates, why we need them, and how to create them.

An introduction to C++ templates, why we need them, and how to create variable templates.

Learn how to use type aliases, using statements and typedef to simplify or rename complex C++ types.

Learn how to create interfaces and abstract classes in C++ using pure virtual functions

Learn how to add conversion functions to our classes, so our custom objects can be converted to other types.

Learn how we can rethrow errors, and wrap exceptions inside other exceptions using standard library helpers.

Learn how to add iterators to our custom classes, so they can be used with range-based for loops.

Learn how exceptions interact with the call stack, and how to use terminate, set_terminate, and abort.

In this lesson, we will learn about the std::exception types that come with the C++ standard library. We will also learn how to create and use our own custom exception types.

A beginner’s introduction to the SDL_ttf library, and how we can use it to add text rendering to our application.

Preparing our development environment for this chapter by Installing SDL2 and the SDL_image and SDL_ttf extensions. Setup guide for Visual Studio on Windows. 

Learn the basics of function try blocks in C++ with this beginner's guide. Discover how to catch exceptions thrown within a function and gracefully handle errors in your code.

Learn how to use the C++ std::forward_list container to create linked lists.

An introduction to linked lists, why we would want to use them, and how they compare to arrays

An introduction to the std::pair data structure within the C++ standard library.

An introduction to a "hash sets" - the ideal container type for when we want to store collections of unique objects

Create maps / dictionaries in C++ using the standard library's std::unordered_map container class.

Learn how to iterate over containers in C++ using code that can work regardless of the specific type of container

Learn how we can use the throw, try and catch statements to let our program manage unexpected situations

Learn how we can ensure that our C++ application is in a correct state using run time and compile time assertions.

An introduction to functors - how to create objects that behave like functions

An introduction to a collection of standard library utilities that can help us when working with first class functions

An introduction to first class functions - a language feature that unlocks many powerful design options

Learn to create functions from existing functions, by providing only some of the arguments.

An introduction to Lambdas - a more concise way of creating functions

Introduction to SDL_Image - add support for different image types. Convert .png and .jpeg files into SDL surfaces, and vice versa

Preparing our development environment for this chapter by Installing SDL2 and the SDL_image and SDL_ttf extensions. Setup guide for Xcode or CMake. 

An introduction to double buffering - the foundational technique behind real time graphics

Learn how to load images into our SDL2 application. Then, learn how to crop, resize, position and render them into our window.

Expanding on our UI architecture to add a simple button to our application, complete with hover and click events.

Guide for building SDL2 from source and setting up a development environment on any system that supports CMake

How to build a simple, scalable and layered UI architecture using an SDL2 and C++ event loop

Learn how SDL2 handles user input, and how we can react to it to update our application in real time.

Setting solid foundations for our application, by implementing the main loop and the event loop

Explanation of automatic storage duration, and why it is important to consider when returning pointers and references from functions

An introduction to how we can store collections of objects into a single container, using the std::vector class

Statements like [[nodiscard]] and [[deprecated]] which we can add to our code to help the compiler and other developers

Learn how to get started with SDL2 in C++ by creating a window. Includes an explanation of all the SDL2 functions we use, and the options we have to modify the window.

An introduction to the bitwise AND, OR, and XOR operators - and one of their most interesting use cases

Guide for building SDL2 from source on MacOS. Including support for Apple Silicon - M1/M2, and setting up a C++ project using Xcode.

Learn an alternative way to manage many different types of object, without heavily relying on classes

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

An introduction to the component-based design pattern, allowing us to create extremely complex objects in a simple, maintainable way

Learn how the scoping rules apply when dealing with inheritance, and how we can bypass them with the Scope Resolution operator

Learn some syntax added to C++ recently, which makes dealing with our structs a little cleaner

Learn how to get user input from the terminal, allowing our program to respond to use requests

Learn how we can use namespaces in the design of our software, and why we'd want to use an anonymous namespace.

Introducing the auto keyword, which will ask the compiler to automatically deduce our data types

Learn more about the use of const and why we should use it throughout our application.

Learn how to deal with times, dates and durations in C++ using the Chrono library

Learn how to implement some more advanced math functions, with some help from the C++ standard library.

Learn how to enhance our C++ classes and structs by overloading unary operators such as ++ and --

An introduction to how our function calls create a call stack, and how we can navigate it in a debugger.

An introduction to dynamic casting of pointers in C++ with examples using std::dynamic_cast

Learn how we can create classes in C++, with variables and functions. Then, create objects from our classes

A deeper look at what is happening when we pass arguments to functions, and an introduction to the problem that references are designed to solve.

Learn how to create references, how to pass them to functions, and some of their limitations.

Discover a better way to initialise our objects from a constructor, which also allows us to fully use references within our classes.

An introduction to pointers - a more powerful type of reference, that carries some additional capabilities.

Learn more about pointers, and how we can use the arrow operator to make our code more readable

A friendly introduction to polymorphism covering what it is, and why it is useful

Using virtual functions to implement a simple example of polymorphism

Learn how we can "downcast" our pointers to let us access functions in derived object types.

An introduction to the C++ preprocessor, and how we can automatically prevent parts of our code from being included when we compile

Learn how we can split our code into multiple files, to keep everything organised. Then, use the include directive to automatically bring them back together for compilation.

An introduction to a big problem with the include directive, and two different methods ways to work around it.

Learn what header files are, why we might want to use them, and get practice implementing them.

Go deeper on how the linker works, and how we can take full advantage of it by using forward declarations and incomplete types.

Learn how we can use namespaces to keep related variables, functions and classes together.

Learn how we can use enumerated classes to deal with scenarios where a value can be one of several possibilities.

An introduction to structs - an alternative to classes that provides another way to define our own data types.

Learn how we can enhance our classes and structs by letting them define their our own operators.

Learn about constants in C++, and how we can use the const and constexpr keywords to make our code better

Learn what makes for useful and effective comments, and some scenarios where we shouldn't use comments at all

Learn how we can automatically format our code, and use the industry standard .clang-format file to control how our code is laid out.

Learn how static analysis tools can suggest improvements to our code, helping us learn faster

Learn the basics of maths and geometry, so we can represent concepts like positions and distances between objects in our worlds.

Learn some more vector math, and see how we can use it to implement gameplay movement.

Explore how we can add randomness to our program, so the outcome isn't always the same

Learn how to overload the << operator, so our custom types can stream information directly to the console using std::cout

In this lesson, we will introduce classes - the fundamental feature of object oriented programming

See how we can use refactoring to keep our code clean, simple and easy to update

An introduction to the problem inheritance is designed to help us solve, and how we can use it to manage future complexity.

Learn how we can implement inheritance in C++, allowing our classes to share functionality

Learn about protected members within classes, and how they differ from public and private members.

See how we can create different versions of functions by using different parameter types

Take control of our data types, and convert between them explicitly using static casting.

Going into more depth on what is happening when a variable is used as a different type

An introduction to two of the most highly performing data structures, and the secret to how they work

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.

Learn more about how and when we can access variables, by understanding the importance of the scope in which they exist.

Understand what function prototypes are, and learn how we can use them to let us order our code any way we want.

Learn how we can use loops to iterate over a block of code, executing it as many times as needed.

Learn how we can use the modulus operator to get the "remainder" of integer division, and some common use cases.

An introduction to Challenges, and the first one - creating a C++ version of the FizzBuzz game.

Making our C++ functions more useful and dynamic by providing them with variables to use in their execution

An introduction to the building blocks of our software - objects, and the variables that can be associated with them.

Unlock the ability to have our functions communicate with each other via their return values

Creating a tiny program using numbers and booleans and adding some break points so we can step through our code in a debugger.

An introduction to functions - reusable blocks of code that we can use to break our application into smaller pieces.

Use booleans and if statements to make our functions and programs more dynamic, choosing different execution paths

Getting our computer set up so we can create and build C++ programs. Then, creating our very first application

An introduction to the different types of numbers in C++, and how we can do basic math operations on them.