Modern C++17 & C++20 Advanced Language Features

Master the full spectrum of C++17 & C++20 standard, core language updates, transformative features like Modules, Concepts, Coroutines, and Ranges, and essential new library components.

Course Description

This course offers a focused, in-depth exploration of C++17 and C++20, covering the language and library features that redefine modern C++ development. Rather than listing features, the course explains why they exist, how they work, and when they should be used.


Each topic is taught through practical, real-world examples, with selective dives into compiler behavior and generated code to clarify performance, object lifetimes, and subtle semantic details. Core features such as concepts, ranges, modules, coroutines, three-way comparison, and modern concurrency utilities are presented in a structured, design-oriented way.


By the end of the course, learners develop a clear mental model of C++17 and C++20, enabling them to write expressive, efficient, and well-reasoned modern C++ code with confidence.


Features

15-hrs On Demand Video

Course Completion Certificate

Priority Q/A

Community Access

Curriculum

Understand in detail on what is planned under each module

Course Introduction

C++20 Topics Overview

Compiler Support for C++20

📊 Course Material

📄 Source Code

Deprecated & Removed Features

Changes

Attributes

Feature Test Macros

ifswitch with Initialization

inline variables

Nested Namespaces

noexcept Change

constexpr Lambda

Structured Bindings

Expression Evaluation Order

Mandatory Copy Elision - I

Mandatory Copy Elision - II

Compile Time if - I

Compile-Time if - II

Class Template Argument Deduction (CTAD)

Concept Of Fold Expressions

Fold Expressions - Unary Folds

Fold Expressions - Binary Folds

Fold Expressions - Summary

Type Traits Suffixes

std::optional - I

std::optional - II

std::optional- III

std::variant - I

std::variant - II

std::variant- III

std::any

std::string_view - I

std::string_view - II

Filesystem - path

Filesystem - directory_entry

Filesystem - directory functions

Filesystem - permissions

Parallel Algorithms - I

Parallel Algorithms - II

Parallel Algorithms - III

Quiz

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

Progress Update

Lambda Expressions - Implicit this Capture

Lambda Expressions - Template Parameters - I

Lambda Expressions - Template Parameters - II

Lambda Expressions - Unevaluated Context

[nodiscard] Attribute

New C++20 Attributes

using enum Declaration

Quiz

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

Motivation

Basics

Examples

requires Usage

Abbreviated Templates

Requirement Types - I

Requirement Types - II

Custom Concepts

Standard Library Concepts

Quiz

Build Process Overview

Module Basics

Naming Modules

Module Compilation

Declaration & Definition Separation

Submodules

Partition Modules

Header Units

Module Private Marker

Course Review

Quiz

Comparison Operators - I

Comparison Operators - II

Three-way Comparison Operator - I

Three-way Comparison Operator - II

Three-way Comparison Operator - III

Three-way Comparison Operator - IV

Synthesized Expressions - I

Synthesized Expressions - II

Comparisons

Equality Operator - I

Equality Operator - II

Equality Operator - III

Ordering Categories

Strong Ordering

Weak Ordering - I

Weak Ordering - II

Partial Ordering - I

Partial Ordering - II

Ordering Summary

Backward Compatibility

Utilities - I

Utilities - II

Utilities - III

Utilities - IV

Summary

Quiz

Algorithms & Iterators

Ranges Introduction

Ranges Example

Range Concepts - I

Range Concepts - II

Range Concepts - III

Projections - I

Projections - II

Projections - III

Algorithm Return Types - I

Algorithm Return Types - II

Algorithm Return Types - III

Views - I

Views - II

Views - III

More Views

View Composition

Pipelines

Range Factories

Course Review

Quiz

Subroutines

Coroutines Introduction

Coroutine Example

Coroutine Anatomy

Coroutine Implementation

Coroutine Workflow - I

Coroutine Workflow - II

Coroutine Workflow - III

Return Values (co_return)

Generators (co_yield)

Awaitable

Awaitable Implementation

Awaiter

Awaiter Implementation - I

Awaiter Implementation - II

Awaiter Methods

Coroutine Concurrency - I

Coroutine Concurrency - II

Coroutine Concurrency - III

Exceptions in Coroutines

Initialization Stage Exceptions

Execution Stage Exceptions - I

Execution Stage Exceptions - II

Conclusion

std::jthread

Thread Stop

Latch

Barrier

Semaphores

Quiz

std::osyncstream

std::source_location

std:span

Span Fixed Extent

Span Dynamic Extent

Spans As Function Parameters

Subspans

std::is_constant_evaluated

std::bind_front

Container Helper Functions

std::erase()/std::erase_if()

std::ssize

std::contains

🏅 Course Certificate

Why Do This Course

Master modern C++17 and C++20 features with correct, production-grade usage.

Move beyond syntax and understand the design intent behind newer language enhancements.

Learn structured bindings, constexpr advancements, concepts, ranges, and more in practical contexts.

Strengthen type safety and API design with concepts and newer language constraints.

Simplify complex asynchronous operations and I/O-bound tasks with C++20 Coroutines

Effectively utilize powerful new library additions like std::format, std::span, and jthread.

Prerequisites

  • 4+ years of professional C++ development experience
  • Strong working knowledge of C++11/14, including templates, lambdas, RAII, and the standard library
  • Comfortable reading non-trivial C++ code and reasoning about object lifetimes and performance
  • Familiarity with basic concurrency concepts (threads, synchronization) is recommended
  • Modern C++ compiler (Visual Studio 2022, gcc 13, clang 17)

Related Products

Additional products that may be relevant to your interests

View All Products
Image23

Instructor


- Hello! I'm Umar Lone

I've educated and mentored students and professionals globally, leveraging over 20 years of experience in C++, Object-Oriented Programming, Design Patterns, and related technologies. My professional background includes significant contributions to C++, Java, and C# projects with esteemed companies, alongside providing specialized project consultation & mentoring.


My current focus is on delivering comprehensive video courses that distill this extensive knowledge. I specialize in transforming intricate concepts into clear, practical, and actionable insights, supported by real-world examples. This approach is designed to equip you with the necessary clarity and confidence for sustained growth and impactful contributions within your projects and career trajectory.


Begin your learning journey with me now and unlock the advanced understanding and practical expertise essential for making a significant impact in your field.


Keep in touch

Subscribe for announcements, new courses & discount coupons

Yes please, save my details so you can send me educational content that is relevant and helpful.