The C++20 Standard
Learn & implement the features from the new C++20 standard
Understand & implement the new C++20 features
Learn about the changes & updates to existing C++ features
Migrate existing C++ codebase to C++20
Use the new Python-style formatting library to format strings
Use modules instead of headers to modularize software
Use ranges library to simplify working with containers & algorithms
Use concepts to apply constraints on algorithms & classes
Use coroutines to write concurrent code
Course Prerequisites
This course only focuses on the new C++20 standard features without going into the basics or details of previous standards of C++ or basics of object-oriented programming. You must've some basic understanding of C++11 in order to follow through in this course. In case, you're not familiar with modern C++ features, check out my other course called Complete Modern C++.
This course will aim to explain the new core language & the library features. You'll learn to use designated initializers, consteval, consinit, unevaluated constext usage of lambda expressions, enum usage, etc. You'll also get to know about the new way through which C++ code is reused without using header files. This is possible through modules, which is a faster and easier way to reuse existing functions or classes.
If you implement classes for use with containers, then you'll have to provide implementation of many comparison operators which becomes tedious and error-prone. C++20 provides a new operator called the three-way comparison operator (space-ship operator) that simplifies implementation of comparison operators. Additionally, it now becomes easier to use algorithms with containers through ranges. No need to use begin() & end() functions to operate on the container.
Concepts is a new way of applying constraints on template arguments. It is much simpler to use as compared to SFINAE (enable_if). Learn & implement concepts to ensure your functions accept the right kind of arguments and avoid runtime errors.
Finally, you'll learn about resumable functions, called coroutines. Using coroutines, you can write concurrent code without the need for synchronization or multiple threads. This enables you to write high performance code without the overhead of creating & destroying threads.
If you're ready, then let's get started right away.
Course Introduction
FREE PREVIEWC++20 Topics Overview
Compiler Support for C++20
A word on source code
Slide Deck
Source Code
Designated Initialization - Aggregate Types
Designated Initialization - Examples
Designated Initialization - More Examples
Init- Statement in Range-Based For Loop - I
Init- Statement in Range-Based For Loop - II
char8_t & std:u8string - I
char8_t & std:u8string - II
Structured Bindings Changes
constexpr Changes
Immediate Functions - conseval
Compile-time Initialization - constinit
Conditionally Explicit Constructor - I
Conditionally Explicit Constructor - II
Conditionally Explicit Constructor - III
Non-Type Template Parameteres
Course Review
Source Code
Lambda Expressions - Implicit this Capture
Lambda Expressions - Template Parameters - I
Lambda Expressions - Template Parameters - II
Lambda Expressions - Unevaluated Context
Source Code
[nodiscard] Attribute
New C++20 Attributes
using enum Declaration
Source Code
Stream Formatting - I
Stream Formatting - II
C++20 Formatting Library
Basic Usage
println Helper Implementation
Format Specification - Type
Format Specification - Fill, Alignment & Width
Format Specification - Number Formatting
Source Code
Motivation
Basics
Examples
requires Usage
Abbreviated Templates
Requirement Types - I
Requirement Types - II
Custom Concepts
Standard Library Concepts
Learn creational design patterns & their implementation in modern C++.
$16.99
Learn structural design patterns & their implementation in modern C++.
$16.99
Learn behavioral design patterns & their implementation in modern C++.
$16.99