Name: The All-in-One Guide to C++20
Author: Rainer Grimm

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, modules, range library, and coroutines.  

You will also cover the additions to the standard library and concurrency in detail. To get the information to sink in, each chapter includes tons of example code for you to get a vivid idea about what to expect from each feature. Lastly, you will get into some case studies to apply the theory into practice.

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

Getting Started

Conventions

Source Code

Introduction

Historical Context

Standardization

About C++

Introduction to C++20

The Big Four

Core Language

The Standard Library

Concurrency

A Quick Overview of C++20

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

Concepts

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

Modules

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

Three-way Comparison Operator

Aggregate Initialization

Named Initialization of Class Members

Exercise: Detect Narrowing Conversion

Solution: Detect Narrowing Conversion

Test Yourself: Designated Initialization

Designated Initialization

The consteval Keyword

The constinit Keyword

Function Execution and Variable Initialization

Solving the Static Initialization Order Fiasco

Test Yourself: consteval and constinit

New Keywords: consteval and constinit

Conditionally Explicit Constructor

Exercise: Manage the Implicit Conversion

Solution: Manage the Implicit Conversion

Non-type Template Parameters

Test Yourself: Template Improvements

Template 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

Lambda Improvements

Introduction to Attributes

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

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

The [[no_unique_address]] Attribute

Test Yourself: New Attributes in C++20

New Attributes in C++20

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

Further Improvements in Core Language

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

The ranges Library

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

std::span

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

Container Improvements

Safe Comparison of Integers

Mathematical Constants

Midpoint and Linear Interpolation

Bit Manipulation

Exercise: Analyze the Output

Solution: Analyze the Output

Test Yourself: Arithmetic Utilities

Arithmetic Utilities

Time of Day

Calendar Dates

Validation of Date

Query Calendar Dates and Weekdays

Calculating Ordinal Dates

Time Zones

Test Yourself: Calendar and Time Zones

Calendar and Time Zones

Overview of the Formatting Library

Format Strings

User-defined Types

Test Yourself: Formatting Library

Formatting Library

std::bind_front Library in C++20

std::is_constant_evaluated Library in C++20

std::source_location Library in C++20

Further Improvements in Standard Library

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

Coroutines

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

Atomics

Overview of Semaphores

Thread Synchronization with Semaphores

Test Yourself: Semaphores

Semaphores

Overview of Latches and Barriers

std::latch

std::barrier

Test Yourself: Latches and Barriers

Latches and Barriers

Overview of Cooperative Interruption Thread

New wait Overloads for the condition_variable_any

Test Yourself: Cooperative Interruption

Cooperative Interruption

Automatically Joining

Cooperative Interruption of a std::jthread

Test Yourself: std::jthread

std::jthread

Output streams with std::cout

Exercise: Synchronize the Output

Solution: Synchronize the Output

The get_wrapped Function

Test Yourself: Synchronized Output Streams

Synchronized Output Streams

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

Case Studies

What's Next?

Summary

Introduction to C++ 23

Coroutine Types in the Coroutines Library

Awaitable Types and Functions in the Coroutines Library

C++23

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

Join 450,000 learners from companies like

Teams of every size choose
Educative for Business
to train, upskill & onboard their developers

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

Join 450,000 learners from companies like

Teams of every size choose Educative for Business to train, upskill & onboard their developers

Teams of every size choose
Educative for Business
to train, upskill & onboard their developers