C++20 is now a year old. Time to take a closer look at the benefits you get when using C++ for standards 11 to 20. You learn about Coroutines by building a coroutine-based parser. The new ranges and the spaceship operator help you write less code. You will learn how Concepts help you to express constraints better and improve error messages. Doing things at compile-time saves run-time. Let‘s see how C++20 improves your code with the new features consteval and constinit. After this talk, you learned some C++20 features and saw the improvements to C++17 code.

Target Audience: Developers
Prerequisites: Knowledge about at least C++11
Level: Advanced       

Extended Abstract
C++20 is now a year old. The major compilers already provide a solid support for the new standard. It is time to take a closer look and figure out the benefits you get when using C++20. Because there are so many improvements in C++20, we will focus on: Concepts, Coroutines, ranges, the spaceship operator, and compile-time evaluation.
Coroutines are the feature that likely will have a strong impact on future finite state machine code. In a brief tour, we will see what we need to do for building a coroutine-based byte-stream parser and how this code is so much more beautiful than without Coroutines.
Less code is always a good thing. The new ranges part of the STL helps us achieve this goal. We will take a brief look at how ranges simplify our code.
Speaking about less code, how about writing a class with all comparison operations without having to write an awful amount of boilerplate code? Sounds good? Then let's see how C++20 helps us there with the spaceship operator.
And while we are speaking about less code, generic programming comes to mind. Concepts give us a whole new way to express constraints and requirements in generic code. Concepts make our code better readable while, at the same time, give us way better error messages.
We don't stop there. Together we will look at the updates to the compile-time world. With consteval and constinit we have two new keywords allowing us new things to do. A lot of former restrictions of constexpr functions were dropped as well. The most popular is probably the ability to dynamically allocate memory at compile-time. We will explore these features using some practical examples.
After this talk, you will have seen the probably most impactful features of C++20. You learned by examples how to use them. The comparisons to pre-C++20 code give you a good understanding of what your benefits are by using C++20.