Learn C++

Explore advanced techniques for managing object copying and resource allocation

Step-by-step guide on creating the SDL2 application and event loops for interactive games

Learn how to detect and handle mouse input events in SDL, including mouse motion, button clicks, and window entry/exit.

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.

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

Explore how C++ programs store and manage numbers in computer memory, including integer and floating-point types, memory allocation, and overflow handling.

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

Explore how header files and linkers streamline C++ programming, learning to organize and link our code effectively

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

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

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

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 the modulus operator to get the remainder of integer division, and some common use cases.

Put everything we've learned in this chapter to the test by creating a C++ version of the Fizz Buzz game.

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

Learn the techniques and pitfalls of manual memory management in C++

Explore the fundamentals of dynamic arrays with an introduction to std::vector

An introduction to the generic engine classes we'll use to create the game

Implement flag placement and tracking to complete your Minesweeper project.

Learn how to create and customize windows, covering initialization, window management, and rendering

Learn how to create a flexible and extensible UI system using C++ and SDL, focusing on component hierarchy and polymorphism.

Explore techniques for building UI components that respond to user input

Learn how to load, display, and optimize image rendering in your applications

Learn to precisely control image display using source and destination rectangles.

Learn techniques for scaling images and working with aspect ratios

Learn to load, manipulate, and save various image formats using SDL_Image.

Designing a flexible component for handling images in SDL-based applications

Key techniques for implementing class designs in more complex scenarios

Explore advanced techniques for optimizing and controlling text rendering when using SDL_ttf

Implement win/loss detection and add a restart feature to complete the game loop

Learn about an important consideration when returning pointers and references from functions

This lesson introduces the using keyword in C++, focusing on namespaces, enums, and type aliasing

Learn how to manage dynamic memory using unique pointers and the concept of memory ownership

Building a two-dimensional grid of interactive minesweeper cells

Updating the game to to place bombs randomly in the grid and render them when cells are cleared.

Implement the techniques for detecting nearby bombs and clearing empty cells automatically.

Learn to render and manipulate text in SDL2 applications using the official SDL_ttf extension

Discover techniques for detecting and responding to SDL runtime errors

Discover how to use the SDL2 event system to handle custom, game-specific interactions

This lesson introduces the fundamentals of capturing user input, using std::cin and std::getline

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

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

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

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 regular expression capture groups, and how to use them in C++ with regex search, replace, iterator, and token_iterator

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

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

A guide to working with and manipulating C-style strings, using the <cstring> library

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

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

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

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

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

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

A guide to simplifying our comparison operators using C++20 features

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

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

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

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

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

A guide to multiple inheritance in C++, including its common problems and how to solve them

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

A deeper look at the C++ linker and how it interacts with our variables and functions. We also cover how we can change those interactions, using the extern and inline keywords

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

An introduction to the eight main comparison algorithms in the C++ Standard Library

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

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

Create, delete, move, and navigate through directories and files using the standard library's filesystem module.

A guide to effectively working with file system paths, using the path type within the standard library's filesystem module.

An introduction to iterating through the file system, using directory iterators and recursive directory iterators

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

An overview of the key C++ standard library algorithms for replacing objects in our containers. We cover replace(), replace_if(), replace_copy(), and replace_copy_if().

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

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

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().

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

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().

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().

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 advantages of binary search, and how to use it with the C++ standard library algorithms binary_search(), lower_bound(), upper_bound(), and equal_range()

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 create and use views in C++ using examples from std::views

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

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

Multithreading in C++ standard library algorithms using execution policies

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

Learn the essentials of double buffering in C++ with practical examples and SDL2 specifics to improve your graphics projects

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

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

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

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

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.

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

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

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

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

An introduction to static arrays 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 why we should avoid them where possible

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

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

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

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

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

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

This lesson provides an introduction to exceptions, detailing the use of 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

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

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

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

A step-by-step guide on setting up SDL2 and useful extensions in a project that uses CMake as its build system

This guide walks you through the process of compiling SDL2, SDL_image, and SDL_ttf libraries from source

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

An introduction to shared memory ownership 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

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

This step-by-step guide shows you how to set up SDL2 in an Xcode or CMake project on macOS

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

A step-by-step tutorial on configuring SDL2, SDL_image and SDL_ttf in a Visual Studio C++ project on Windows

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

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

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

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

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

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

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

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

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

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

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

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 and practical tutorial for working with HTTP in modern C++ using the cpr library.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

This lesson introduces system calls, and how to use them to clear the terminal

Unravel the fundamentals of bitwise operators and bit flags in this practical lesson

Explore the fundamentals of attributes, including [[nodiscard]], [[likely]], and [[deprecated]]

This lesson covers the basics of using randomness, with practical applications

Learn the basics of the chrono library and discover how to effectively manage durations, clocks, and time points

A detailed guide to string formatting using C++20's std::format(), and C++23's std::print()

This lesson provides an overview of effective commenting strategies, including Javadoc style commenting for automated documentation

This lesson introduces the concept of Style Guides and ClangFormat, focusing on how to achieve consistency in our code

An introduction to static analysis tools, and how they can help beginners learn faster and improve code quality

This lesson covers how we can ask the compiler to infer what types we are using through the auto keyword

Learn the intricacies of using const and how to apply it in different contexts

Learn the essentials of using namespaces to organize your code and handle large projects with ease

Learn about Enums and how they offer an efficient way to handle predefined values in your code

Explore the essential concepts of C++ preprocessing, from understanding directives to implementing macros

Discover how the #include directive helps us include library features and split our project across multiple files.

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

This lesson introduces operator overloading, a fundamental concept to create more intuitive and readable code by customizing operators for user-defined types

This lesson provides a thorough introduction to pointers in C++, covering their definition, usage, and the distinction between pointers and references

Learn about the this pointer in C++ programming, focusing on its application in identifying callers, chaining functions, and overloading operators.

This lesson provides an in-depth look at function overloading in C++, covering its importance, implementation, and best practices

Explore the concept of static casting in C++, including examples and best practices for converting data types at compile time

This lesson provides an introduction to virtual functions and overrides, focusing on their role in enabling runtime polymorphism

Get to grips with downcasting in C++, including static and dynamic casts. This lesson provides clear explanations and practical examples for beginners

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

This lesson introduces Member Initializer Lists, focusing on their advantages for performance and readability, and how to use them effectively

This lesson provides an in-depth exploration of using inherited methods and variables in C++, covering constructor calls, variable modification, and function shadowing

This lesson demystifies references, explaining how they work, their benefits, and their role in performance and data manipulation

Learn how to define, instantiate, and utilize classes, understanding how they form the backbone of object-oriented programming.

A guide to encapsulation, class invariants, and controlling data access with public and private specifiers.

Learn about special functions we can add to our classes, control how our objects get created and destroyed.

Discover the role of structs, how they differ from classes, and how to initialize them without requiring a constructor.

This lesson introduces Structured Binding, a handy tool for quickly unpacking simple data structures

In this lesson, we delve into C++ inheritance, guiding you through creating and managing class hierarchies to streamline your code

Allow our functions to communicate with their caller by returning values when they complete

Making our functions more useful and dynamic by providing them with additional values to use in their execution

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

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

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 a tiny program using numbers and booleans, then adding some breakpoints 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.

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

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

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

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

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