Free, Unlimited Access

Pro C++

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

9,018 Reviews

257,041 Learners

Updated 3 Days Ago

C++SDL

Continue your Journey

Progress directly from our introductory course, expanding your programming knowledge to more advanced concepts.

We also have follow-ups to this course, where we build complex, portfolio-ready projects.

Understand Every Line of Code

No copying-and-pasting code in this course.

We explain every line of code we're using, so you understand exactly what is happening.

Use Professional Best Practices

Everything we create is organised and implemented using modern, professional practices.

This means the techniques we learn are usable in large, professional projects.

Focus on Transferrable Skills

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.

Free, unlimited access

This course includes:

124 Lessons
550+ Code Samples
96% Positive Reviews
Regularly Updated
Help and FAQ

Not Ready Yet?

Subscribe to this course to return to it later, and get updates on future changes

Requirements
Who is this Course For?

This course is intended for those who already have a basic familiarity with object oriented programming in C++. It is designed as a follow up for our introductory course:

Prerequisite Course

Intro to C++ Programming

Become a software engineer with C++. Starting from the fundamentals, we guide you step by step along the way.

Screenshot from The Witcher 3: Wild Hunt

Those who already have some knowledge of C++, or are familiar with object oriented programming in another language, may be able to skip the introductory course.

The first chapter of this pro course includes a summary of the topics covered, to help you get caught up.

Chapter 1
Whirlwind Tour of C++ Basics

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

Abstract art representing computer programming

Chapter 2
Memory Management

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

Memory Management and the Stack

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

Dynamic Memory and the Free Store

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

Smart Pointers and `std::unique_ptr`

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

Shared Pointers using `std::shared_ptr`

An introduction to shared memory ownership using std::shared_ptr

Weak Pointers with `std::weak_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

Copy Semantics and Return Value Optimization

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

Illustration representing computer hardware

Move Semantics

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

Value Categories (L-Values and R-Values)

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

Chapter 3
Templates

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

Type Aliases

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

Class Templates

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

Templates and Header Files

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

Compile-Time Evaluation

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

Variable Templates

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

Function Templates

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

Member Function Templates

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

Template Specialization

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

Chapter 4
Type Traits and Concepts

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

Understanding Overload Resolution

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

Type Traits: Compile-Time Type Analysis

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

Using SFINAE to Control Overload Resolution

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

Concepts in C++20

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

Creating Custom Concepts

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

Using Concepts with Classes

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

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

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

Chapter 5
Exceptions and Error Handling

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

Errors and Assertions

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

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

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

Exception Types

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

`std::terminate` and the `noexcept` specifier

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

Storing and Rethrowing Exceptions

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

Nested Exceptions

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

Function Try Blocks

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

Chapter 6
Arrays and Linked Lists

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

Static Arrays using `std::array`

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

C-Style Arrays

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

Array Spans and `std::span`

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

Multidimensional Arrays and `std::mdspan`

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

3D art showing a woman in a cyberpunk character

Algorithm Analysis and Big O Notation

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

Data Structures and Algorithms

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

Iterators

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.

Working with Linked Lists using `std::forward_list`

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

Chapter 7
Hash Sets and Hash Maps

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

3D art showing a character looking at a screen

Hashing and `std::hash`

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

Implementing Hash Sets using `std::unordered_set`

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

Using `std::pair`

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

Implementing Hash Maps using `std::unordered_map`

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

Chapter 8
Standard Library Data Structures

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

Nullable Values using `std::optional`

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

Unions and `std::variant`

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

Void Pointers and `std::any`

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

Tuples and `std::tuple`

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

Introduction to Queues and `std::queue`

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

Priority Queues using `std::priority_queue`

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

Introduction to Stacks using `std::stack`

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

Double-Ended Queues using `std::deque`

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

Chapter 9
Working with Functions

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

First Class Functions

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

Function Pointers

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

Function Objects (Functors)

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.

Lambdas

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

Standard Library Function Helpers

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

Function Binding and Partial Application

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

Trailing Return Types

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

Recursion and Memoization

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

Variadic Functions

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

Fold Expression

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

Perfect Forwarding and `std::forward`

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

Chapter 10
Iterators and Ranges

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

Iterators and Ranges

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

Implementing Ranges for Custom Types

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

Defining Ranges using Sentinels

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

Creating Custom Iterators using C++20 Concepts

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

Iterator and Range-Based Algorithms

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

Projection Functions

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

Standard Library Views

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

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

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

8 Key Standard Library Algorithms

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

Parallel Algorithm Execution

Multithreading in C++ standard library algorithms using execution policies

Chapter 11
Standard Library Algorithms

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

Search Algorithms

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.

Binary Search in C++

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

Counting Algorithms

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

Minimum and Maximum Algorithms

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

Movement Algorithms

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

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

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

Replacement Algorithms

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

Partition Algorithms

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

Set Algorithms

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

Comparison Algorithms

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

The Reduce and Accumulate Algorithms

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

C++23 Fold Algorithms

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

Chapter 12
Objects, Classes and Modules

A deeper look at classes and objects, allowing us to empower our custom types with more advanced capabilities.

Internal and External Linkage

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

Static Class Variables and Functions

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

Friend Classes and Functions

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

Mutable Class Members

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

Multiple Inheritance and Virtual Base Classes

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

Pure Virtual Functions, Abstract Classes, and Interfaces

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

List, Aggregate, and Designated Initialization

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

User Defined Conversions

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

User Defined Literals

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

The Spaceship Operator and Expression Rewriting

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

C++20 Modules

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.

Chapter 13
Strings and Streams

Develop a deeper understanding of strings in C++, and how we can use them with streams to transfer data between components.

Characters, Unicode and Encoding

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

Working with C-Style Strings

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

A Deeper Look at the `std::string` Class

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

Manipulation and Memory Management of `std::string`

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

Regular Expressions

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

Regex Capture Groups

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

String Views

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

Working with String Views

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

Output Streams

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

String Streams

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

Input Streams

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.

Chapter 14
Files and Serialization

Learn how we can serialize parts of our program, enabling us to save and restore objects from the user's hard drive.

Working with the File System

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

File System Paths

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

Directory Iterators

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

File Streams

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

Chapter 15
Libraries and Dependencies

Learn how to use third party libraries to gain quick and easy access to new and powerful capabilities

Installing vcpkg on Windows

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

Using JSON in Modern C++

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

Using HTTP in Modern C++

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

Binary Serialization using Cereal

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

Up Next
Recommended Lessons

Continue your progress in this course with the following lessons. These are recommended for you based on your progress:

More Coming Soon

Professional C++

This course is currently under construction. Additional lessons are added every few days!

Contact|Privacy Policy|Terms of Use

Pro C++

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

Continue your Journey

Understand Every Line of Code

Use Professional Best Practices

Focus on Transferrable Skills

This course includes:

Not Ready Yet?

RequirementsWho is this Course For?

Intro to C++ Programming

Chapter 1 Whirlwind Tour of C++ Basics

Variables, Types and Operators

Introduction to Functions

Namespaces, Includes, and the Standard Library

Conditionals and Loops

Classes, Structs and Enums

Preprocessor Directives and the Build Process

Understanding Reference and Pointer Types

Operator Overloading

Run-time Polymorphism

Odds and Ends: 10 Useful Techniques

Chapter 2 Memory Management