A screenshot from Tomb Raider

Free, Unlimited Access

Pro C++

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

2,834 Reviews

80,789 Learners

Updated 21 Hours Ago

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:

106 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:

Screenshot from Cyberpunk 2077

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 Cyberpunk 2077

Screenshot from The Witcher 3: Wild Hunt

Screenshot from Warhammer: Total War

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.

Variables, Types and Operators

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

Functions and Scope

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

Namespaces, Includes, and the Standard Library

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

Conditionals and Loops

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

Classes, Structs, and Enums

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

Preprocessor, Build Process, and Header Files

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

References and Pointers

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

Overloading Operators

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

Polymorphism

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

Odds and Ends

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

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.

C++ Memory Management - The Stack

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

Dynamic Memory - The Free Store and the Heap

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

Memory Ownership with Smart Pointers, and `unique_ptr`

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

C++ Shared Pointers using `shared_ptr`

An introduction to shared memory ownership using std::shared_ptr

C++ 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, Elision, and RVO

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

Move Semantics, `std::move` and rvalues

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

Chapter 3
Templates

An introduction to the C++ type system, and how we can use advanced compile-time techniques to take full advantage of it.

C++ Type Aliases

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

Variable Templates

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

Class Templates

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

DreamShaper_v7_fantasy_female_pirate_Sidecut_hair_black_clothi_1.jpg

Function Templates

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

Template Specialization

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

DreamShaper_v7_fantasy_female_pirate_Sidecut_hair_black_clothi_0.jpg

Type Traits

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

C++20 Concepts

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

Chapter 4
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

Fixed size arrays using `std::array`

An introduction to arrays in C++ 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 their many problems

3D Concept Art

Array Views using `std::span`

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

Character Concept Art

Multidimensional Arrays and `std::mdspan`

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

Linked Lists vs Arrays

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

DreamShaper_v7_fantasy_female_pirate_Sidecut_hair_swords_black_1.jpg

`forward_list` - Create Linked Lists in C++

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

Chapter 5
Under Construction
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.

3D Concept Art

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

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

3D Character Concept Art

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

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

3D Character Concept Art

Void Pointers and `std::any`

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

Storing two values in a single variable using `std::pair`

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

Tuples and `std::tuple`

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.

Using unordered sets to store unique objects

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

DreamShaper_v7_fantasy_male_pirate_Sidecut_hair_swords_black_c_1.jpg

Using unordered maps to create associative containers

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

C++ Queues using `std::queue`

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

C++ Priority Queues

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

3D concept art of an office worker

Stack Data Structures using `std::stack`

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

3D character concept art

Double-Ended Queues using `std::deque`

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

Chapter 6
Working with Functions

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

DreamShaper_v7_fantasy_female_pirate_Sidecut_hair_black_clothi_3.jpg

First Class Functions

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

Function Pointers

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

C++ Functors (Function Objects)

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

C++ Lambdas

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

C++ Standard Library Function Helpers

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

C++ Binding and Currying

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

3D Concept Art

Trailing Return Types

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

Recursion and Memoization in C++

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

3D Character Concept Art

Variadic Functions

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

Fold Expressions

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

3D Character Concept Art

Perfect Forwarding and `std::forward`

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

Chapter 7
Under Construction
Iterators and Algorithms

An overview of important techniques and standard library algorithms that can help us work with our collections of objects.

C++ Iterators and Range Based For Loops

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

Range Based For Loops with Custom Types

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

Range Based Algorithms and `std::ranges::sort`

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

3D Character Concept Art

Ranges and Sentinels

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

3D Character Concept Art

Creating Custom Iterators using C++20 Concepts

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

Projections and Algorithms

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

DreamShaper_v7_fantasy_female_space_pirate_Sidecut_hair_black_1.jpg

Standard Library Views

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

3D concept art

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

Chapter 8
Under Construction
Standard Library Algorithms

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

DreamShaper_v7_hipster_Sidecut_hair_modest_clothes_fully_cloth_0.jpg

C++ 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.

DreamShaper_v7_queen_Sidecut_hair_modest_clothes_fully_clothed_1.jpg

Binary Search in C++

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

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

DreamShaper_v7_hipster_Sidecut_hair_modest_clothes_fully_cloth_1.jpg

Minimum and Maximum Algorithms

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

DreamShaper_v7_artist_Sidecut_hair_modest_clothes_fully_clothe_3.jpg

C++ 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.

C++ Copying Algorithms

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.

DreamShaper_v7_priestess_Sidecut_hair_modest_clothes_fully_clo_0.jpg

C++ Replace, Remove, and Erase Algorithms

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.

3D Character Concept Art

Partition Algorithms

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

3D Character Concept Art

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

3D Character Concept Art

Reduce and Accumulate

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

Fold Algorithms

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

Chapter 9
Exceptions and Error Handling

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

C++ Assertions: `assert` and `static_assert`

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

`throw`, `try` and `catch` in C++

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

C++ Exception Types

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.

Exceptions and the Call Stack

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

DreamShaper_v7_hipster_Sidecut_hair_modest_clothes_fully_cloth_2.jpg

Rethrowing and Nested Exceptions

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

C++ Function Try Blocks

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.

Chapter 10
Under Construction
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, how it interacts with our variables and functions, and how we can control it using the extern and inline keywords

Static Class Variables and Functions

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

DreamShaper_v7_nurse_Sidecut_hair_modest_clothes_fully_clothed_2.jpg

Friend Classes and Functions

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

Character Concept Art

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 how our classes can derive from multiple ancestors in C++, including the common problems and how to solve them

Pure Virtual Functions, Abstract Classes and Interfaces

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

Character Concept Art

List, Aggregate, and Designated Initialization

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

DreamShaper_v7_surgeon_Sidecut_hair_modest_clothes_fully_cloth_3.jpg

User Defined Conversions in C++

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 automatic expression rewriting, and the new spaceship operator added in C++20

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 11
Strings and Streams

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

DreamShaper_v7_scientist_Sidecut_hair_black_clothing_fully_clo_2.jpg

Characters, Unicode and Encoding

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

DreamShaper_v7_hipster_Sidecut_hair_modest_clothes_fully_cloth_3 (1).jpg

Working with C-Style Strings

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

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

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

`std::string` Manipulation and Memory Management

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

DreamShaper_v7_barista_Sidecut_hair_modest_clothes_fully_cloth_2.jpg

Regular Expressions in C++

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 in C++

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

Concept art showing a 3D fantasy sea monster

String Views using `std::string_view`

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

3D Character Concept Art

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

C++ Output Streams

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

C++ String Streams

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

DreamShaper_v7_hipster_Sidecut_hair_modest_clothes_fully_cloth_0 (1).jpg

C++ Input Streams

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.

Chapter 12
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 in C++

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

C++ File Streams

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

Installing vcpkg on Windows

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

DreamShaper_v7_hipster_Sidecut_hair_modest_clothes_fully_cloth_3.jpg

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 in C++ 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!

Screenshot from Warhammer: Total War

Screenshot from Tomb Raider

Screenshot from Jedi: Fallen Order

Contact|Privacy Policy|Terms of Use

Copyright © 2023 - All Rights Reserved