The All-in-One Guide to C++20

Takeaway Skills

Writing more generic programs using concepts

Overcoming the deficiency of legacy headers and macros with modules

Using algorithms that operate directly on containers

Writing asynchronous programs that are highly valuable in event-driven systems

Writing more generic programs using concepts

Overcoming the deficiency of legacy headers and macros with modules

Using algorithms that operate directly on containers

Writing asynchronous programs that are highly valuable in event-driven systems

Course Overview

This course is your complete guide to the latest version of C++: C++20. You will run through the flagship features of C++20 but also every minor addition to C++. Initially, you will learn the details of the new standard and most notably, you will focus on the big four: concepts, modul... See More

How You'll Learn

Hands-on coding environments

You don’t get better at swimming by watching others. Coding is no different. Practice as you learn with live code environments inside your browser.

Faster than videos

Videos are holding you back. The average video tutorial is spoken at 150 words per minute, while you can read at 250. That‘s why our courses are text-based.

No set-up required

Start learning immediately instead of fiddling with SDKs and IDEs. It‘s all on the cloud.

Progress you can show

Built in assessments let you test your skills. Completion certificates let you show them off.

Hands-on coding environments

You don’t get better at swimming by watching others. Coding is no different. Practice as you learn with live code environments inside your browser.

Faster than videos

Videos are holding you back. The average video tutorial is spoken at 150 words per minute, while you can read at 250. That‘s why our courses are text-based.

No set-up required

Start learning immediately instead of fiddling with SDKs and IDEs. It‘s all on the cloud.

Progress you can show

Built in assessments let you test your skills. Completion certificates let you show them off.

Course Contents

Show All

Show All Lessons

1. Introduction

Getting Started

Conventions

Source Code

2. About C++

Historical Context

Standardization

3. A Quick Overview of C++20

Introduction to C++20

The Big Four

Core Language

The Standard Library

Concurrency

4. Concepts

Two Wrong Approaches

Advantages of Concepts

Four Ways to Use Concepts

Exercise: Implement Arithmetic Concept

Solution: Implement Arithmetic Concept

Use-cases for Concepts

More on Uses-cases for Concepts

Constrained and Unconstrained Placeholders

Abbreviated Function Templates

Predefined Concepts - Part I

Predefined Concepts - Part II

Defining Concepts

Exercise: Modify the sum Function

Solution: Modify the sum Function

Requires Expressions

The Concepts Equal and Ordering

The Concepts SemiRegular and Regular

Exercise: Simplifying the Generic Functions

Solution: Simplifying the Generic Functions

Concluding Concepts

Test Yourself: Concepts in C++20

5. Modules

Need for Modules

Advantages of Modules

A First Example

Compilation and Use

Export

Guidelines for a Module Structure

Module Interface Unit and Module Implementation Unit

Submodules and Module Partitions

Templates in Modules

Module Linkage

Header Units

Test Yourself: Modules in C++20

6. Three-way Comparison Operator

Ordering before C++20

The Compiler-generated Spaceship Operator

Rewriting Expressions

Exercise: Extend MyInt Class

Solution: Extend MyInt Class

User-defined and Auto-generated Comparison Operators

Test Yourself: Three-way Comparison Operator

7. Designated Initialization

Aggregate Initialization

Named Initialization of Class Members

Exercise: Detect Narrowing Conversion

Solution: Detect Narrowing Conversion

Test Yourself: Designated Initialization

8. New Keywords: consteval and constinit

The consteval Keyword

The constinit Keyword

Function Execution and Variable Initialization

Solving the Static Initialization Order Fiasco

Test Yourself: consteval and constinit

9. Template Improvements

Conditionally Explicit Constructor

Exercise: Manage the Implicit Conversion

Solution: Manage the Implicit Conversion

Non-type Template Parameters

Test Yourself: Template Improvements

10. Lambda Improvements

Template Parameter for Lambdas

Detection of the Implicit Copy of the this Pointer

Lambdas in an Unevaluated Context and Stateless Lambdas

Test Yourself: Lambda Improvements

11. New Attributes in C++20

Introduction to Attributes

The [[nodiscard("reason")]] Attribute

The [[likely]] and [[unlikely]] Attributes

The [[no_unique_address]] Attribute

Test Yourself: New Attributes in C++20

12. Further Improvements in Core Language

The volatile Keyword

Range-based for Loop with Initializers

Virtual constexpr Function

The new Character Type of UTF-8 Strings: char8_t

using enum in Local Scopes

Default Member Initializers for Bit Fields

13. The ranges Library

Overview of the ranges Library

Exercise: Compute the Average

Solution: Compute the Average

The Concepts Ranges and Views

Direct on the Container

Function Composition

Lazy Evaluation

A Flavor of Python

Exercise: Implement Python's map Function

Solution: Implement Python's map Function

Test Yourself: The ranges Library

14. std::span

Static versus Dynamic Extent

Deducing the Size of a Contiguous Sequence of Object

Create a std::span from a Pointer and a Size

Modifying the Referenced Objects

Addressing the std::span Elements

A Constant Range of Modifiable Elements

Test Yourself: The std::span Container

15. Container Improvements

constexpr Containers and Algorithms

std::array Container in C++20

Consistent Container Erasure

contains for Associative Containers

Exercise: Erase the Capital Letters

Solution: Erase the Capital Letters

String prefix and suffix checking

Test Yourself: Container Improvements

16. Arithmetic Utilities

Safe Comparison of Integers

Mathematical Constants

Midpoint and Linear Interpolation

Bit Manipulation

Exercise: Analyze the Output

Solution: Analyze the Output

Test Yourself: Arithmetic Utilities

17. Calendar and Time Zones

Time of Day

Calendar Dates

Validation of Date

Query Calendar Dates and Weekdays

Calculating Ordinal Dates

Time Zones

Test Yourself: Calendar and Time Zones

18. Formatting Library

Overview of the Formatting Library

Format Strings

User-defined Types

Test Yourself: Formatting Library

19. Further Improvements in Standard Library

std::bind_front Library in C++20

std::is_constant_evaluated Library in C++20

std::source_location Library in C++20

20. Coroutines

Overview of Coroutines

Characteristic of Coroutines

The Framework

Awaitables and Awaiters

The Workflow

The co_return Keyword

The co_yield Keyword

The co_await Keyword

Test Yourself: Coroutines

21. Atomics

std::atomic_ref

Specializations of std::atomic_ref

Atomic Smart Pointers

std::atomic_flag Extensions

One Time Synchronization of Threads

std::atomic Extensions

Exercise: Try Different Synchronization Techniques

Solution: Try Different Synchronization Techniques

Test Yourself: Atomics

22. Semaphores

Overview of Semaphores

Thread Synchronization with Semaphores

Test Yourself: Semaphores

23. Latches and Barriers

Overview of Latches and Barriers

std::latch

std::barrier

Test Yourself: Latches and Barriers

24. Cooperative Interruption

Overview of Cooperative Interruption Thread

New wait Overloads for the condition_variable_any

Test Yourself: Cooperative Interruption

25. std::jthread

Automatically Joining

Cooperative Interruption of a std::jthread

Test Yourself: std::jthread

26. Synchronized Output Streams

Output streams with std::cout

Exercise: Synchronize the Output

Solution: Synchronize the Output

The get_wrapped Function

Test Yourself: Synchronized Output Streams

27. Case Studies

Case Study I: Fast Synchronization of Threads

Case Study II: Variations of Futures

Case Study III: Modification and Generalization of a Generator

Case Study IV: Various Job Workflows

28. Summary

What's Next?

29. C++23

Introduction to C++ 23

Coroutine Types in the Coroutines Library

Awaitable Types and Functions in the Coroutines Library

static_thread_pool in Coroutine Library

Modularized Standard Library for Modules

Executors

The Network Library

30. C++23 or Later

Contracts

Reflection

Pattern Matching

Further Information about C++23

31. Feature Testing of C++

Feature Testing