C++ – Updating Knowledge from Older Versions to C++20/23/26 (CPPU)

Course content:

Hide details

• What the New Versions of C++ Bring
1. Tools for greater readability and reliability
2. Improving performance and latency in the embedded world
3. C++20 and C++23 tools, expectations for C++26

• Various Small Improvements
1. Formatted output and std::println
2. Changes in the initialization of values and variables
3. The spaceship operator and strong or weak ordering

• Interesting Specialized Tools
1. Multiple values during indexing
2. Calculations with std::lerp
3. Endianness and byteswap

• Working with Directory Structures
1. Traversing directory structures
2. Modifying files and directories
3. Interaction with the rest of the standard library

• Working with Parts of Arrays and Strings
1. Contiguous sequences and std::span
2. Passing strings and std::string_view
3. Advantages and risks of views into memory

• Improved Container Handling
1. Removing elements with std::erase
2. Decomposing with structured bindings
3. Moving away from direct iterator use

• How Ranges and Views Work
1. The relationship between ranges, views, and containers
2. What is wrong with iterators in C++
3. What to watch out for with ranges

• Tools for Filtering and Transformation
1. Views as lazy iterators
2. Chaining operations on views
3. Which views are available

• Modern Thread Handling
1. Futures and promises
2. Working with std::jthread
3. Using std::async

• Asynchronous Calls Using Callbacks
1. Passing callbacks to events
2. Composing callback sequences
3. The coroutine-based approach

• Coroutines and Asynchronous I/O
1. Motivation for using coroutines
2. External libraries with a scheduler
3. Potential impacts in the embedded world

• Asynchronous Network Communication
1. Communication using TCP/IP
2. HTTP server and client
3. Concurrency with other operations

• Compute Threads and Coroutines
1. Coroutines are intended to handle I/O
2. CPU-bound versus I/O-bound
3. Combining threads and coroutines

• Templates and Their Specialization
1. Special handling of specific cases
2. Specialization using tagging and policies
3. Metafunctions and compile-time computations

• Constraining Type Parameters
1. Documenting type requirements
2. SFINAE and programming with type traits
3. Explicit constraints and concepts

• More Convenient Work with Templates
1. Abbreviated function templates
2. Deducing this and perfect forwarding
3. CTAD and omitting type parameters

• Combining OOP and Templates
1. Using inheritance without virtual methods
2. Adding functionality with CRTP
3. Type erasure and std::any

• Libraries in Header Files
1. The modern meaning of the inline keyword
2. ODR and how it all works
3. Combining it with templates and classes

• Metaprogramming Beyond Templates
1. The constexpr, consteval, and constinit keywords
2. The if constexpr and if consteval conditions
3. Using static_assert()

• Combining constexpr and Templates
1. Branching by type at compile time
2. Significantly simplifying some templates
3. constexpr function and variable templates

• Modularity
1. Header files and #pragma once
2. Custom modules and modifying the ODR
3. The standard library in module form

• Lambdas and Their Improvements
1. Implicit and explicit templates
2. Lambdas with constexpr and consteval
3. Implicit behavior of a stateless lambda

• Error Handling Without Exceptions
1. The std::expected return value
2. Working with std::optional
3. Chaining monadic operations

• Heap-Free Runtime Polymorphism
1. The polymorphic type std::variant
2. Applying overloads with std::visit
3. From lambda templates to the overloaded pattern