The Next Big Thing: C++20

C++98

At the end of the 80ths, Bjarne Stroustrup and Margaret A. Ellis wrote their famous book Annotated C++ Reference Manual (ARM). These books served two purposes. First, there were many independent C++ implementations. ARM defined, therefore, the functionality of C++. Second, ARM was the base for the first C++ standard: C++98 (ISO/IEC 14882). C++98 had a few important features: templates, the standard template library (STL) with its containers and algorithms, strings, and IO streams.

C++03

With C++03 (14882:2003), C++98 got a technical correction that is so small that there is no place on my timeline. In the community, C++03, which includes C++98, is called legacy C++. 

TR1

In 2005 something very interesting happened. The so-called technical report 1 (TR1; ) was published. TR1 was a big step toward C++11 and, therefore, towards Modern C++. TR1 (TR 19768) is based on the boost project which was founded by members of the C++ standardisation committee. TR1 has 13 libraries that should become part of the next C++ standard. For example, the library to the regular expression library, the random number library, smart pointers such as std::shared_ptr and hashtables. Only the so-called special mathematic functions had to wait until C++17.

C++11

C++11 stands for the next C++ standard but we just call it Modern C++. This name holds also true for C++14 and C++17. C++11 has many features which fundamentally changed the way we program C++.  For example, C++11 brought the components of the TR1, but also move-semantic, perfect forwarding, variadic templates, or constexpr. But this not all. With C++11 we got the first time memory model as the fundamental base of threading and a threading API. If you are curious, here are my post on the memory model and multithreading in general.

C++14

C++14 is a small C++ standard. It brought read-writer locks, generalised lambdas, and generalised constexpr functions.

C++17

C++17 is neither big nor small. It has two outstanding features: the parallel STL and the standardised filesystem. About 80 algorithms of the STL can be executed with a so-called execution policy. This means, a call std::sort(std::execute::par, vec.begin(), vec.end()) is a hint for the C++ implementation to sort the container vec in a parallel way. Additionally, you can specify that the sort should be done sequential (std::execution::seq), or vectorised (std::execution::par_unseq). As for C++11, boost was also highly influential for C++17. We got the filesystem from boost and the three new data types: std::optional, std::variant, and std::any. Here are my posts to C++17.

C++20

C++20 will change the way we program C++ as fundamentally as C++11. This holds is, in particular, true for the big four: Ranges, Coroutines, Concepts, and Modules. A half year ago, I would write the big five, but contracts were removed in standardisation meeting this year in Cologne. A contract specifies in a precise and checkable way interfaces for software components. My post C++ Core Guidelines: A Short Detour to Contracts in C++20 gives you more details. I should not write about the past. Here is the bright shining upcoming future.

The new ranges library enables it to express algorithms directly on the container, compose the algorithm with the pipe symbol and apply them onto infinite data streams.

Thanks to Coroutines asynchronous programming in C++ may become mainstream. Coroutines are the base for cooperative tasks, event loops, infinite data streams, or pipelines.

Concepts will change the way we think and program templates. They are semantic categories for the valid template arguments. They enable you to express your intention directly in the type of system. If something goes wrong, you will get a short error message.

Modules will overcome the restrictions of header files. They promise a lot. For example, the separation of header and source files becomes as obsolete as the preprocessor. In the end, we will also have faster build times and an easier way to build packages.

But this by far not all. Here are a few additional highlights:

• the three-way comparison operator <=>
• strings literals as template parameters
• calendar and time-zone extensions of the chrono library
• std::span as a view on a contiguous array
• constexpr virtual function
• redefinition of volatile
• additions to the atomics: std::atomic_ref<T> and std::atomic<std::shared_ptr<T>>; waiting on atomics
• new synchronisation mechanisms such as semaphores, latch, and barriers
• constexpr containers such as std::string and std::vector
• an improved thread std::jthread, which joins automatically and can be stopped

Naming

Okay, we should give the new child a name, because the existing C++ standards have all informal names.

• Legacy C++: C++98, and C++03
• Modern C++: C++11, C++14, and C++17
• <To be filled>: C++20, C++23 ...

This name discussion is difficult. In April, I had the same question on Twitter. Here is the tweet,

How should we call C++20 and the beyond area?
C++98 - C++03: Legacy C++
C++11 - C++17: Modern C++
C++20 - C++.. :
Honestly, I don't know.

— Rainer Grimm (@rainer_grimm) April 28, 2019

and here are a few of the more than 50 answers. I added the twitter names to the suggestions.