![\"TimelineCpp20BigFourUpdate\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/10\/TimelineCpp20BigFourUpdate.png\")
<\/p>\nThis post presents you the big four: concepts, ranges, coroutines, and modules.<\/p>\n
<\/p>\n
<\/p>\n
C++20 has a lot to offer. Before I give you a first impression of the big four, here is an overview of C++20. Besides the big four, many features affect the core language, the library, and the concurrency capabilities of C++20.<\/p>\n
Playing with the new features is the easiest way to get used to them. Okay. This approach arises immediately the question: Which C++20 features are supported by which compiler? As so often, cppreference.com\/compiler_support<\/a> gives you the answer to the core language and the library.<\/p>\n To make it simple, the brand-new GCC, Clang, and EDG compilers give the best support to the core language. Additionally, the MSVC and Apple Clang compiler support also many C++20 features.<\/p>\n The story is similar to the library. GCC has the best support for the library, followed by Clang and the MSVC compiler.<\/p>\n The screenshots show only the beginning of the tables, but they also give you an answer which is not so satisfying. Even if you use all brand-new compilers, many features are not supported by any compiler.<\/p>\n Often, you find workarounds to play with the new features. Here are two examples:<\/p>\n To make my story short. The situation is not so bad. With a bit of tinkering, many new features can be tried out. I will mention this little tinkering if necessary. But now, let me give you a bird-eyes view of the new features. Of course, we should start with the big four.<\/p>\n The key idea of generic programming with templates is to define functions and classes which can be used with various types. Often it happens that you instantiate a template with the wrong type. The result is typically a few pages of cryptic error messages. This sad story ends with concepts. Concepts empower you to write requirements for your templates which the compiler can check. Concepts revolutionize the way we think about and write generic code. Here is why:<\/p>\n However, this is not the end of the story.<\/p>\n The following code snippet shows you the definition and the usage of the straightforward concept Integral<\/span>:<\/p>\n Integral is the concept that requires from it type-parameter T<\/span> that std::is_integral<T>::value <\/span>holds. std::is_integral<T>::value<\/span> is a function from the type-traits library which checks at compile-time if T<\/span> is integral. If std::is_integral<T>::value<\/span> evaluates to true,<\/span> all is fine. If not, you get a compile-time error. Here are my posts to the type-traits library for the curious ones – and you should be curious.<\/p>\n The gcd algorithm determines the greatest common divisor based on the Euclidean algorithm<\/a>.\u00a0 I used the so-called abbreviated function template syntax to define gcd.<\/span> gcd<\/span> requires, from its arguments and return type, that they support the concept Integral<\/span>.\u00a0 gcd<\/span> is a function template that puts requirements on its arguments and return value. When I remove the syntactic sugar<\/a>, maybe you can see the fundamental nature of gcd<\/span>.<\/p>\n Here is the semantically equivalent gcd<\/span> algorithm.<\/p>\n If you don’t see the fundamental nature of gcd<\/span>, you have to wait for my posts to concepts in a few weeks.<\/p>\n The ranges library is the first customer of concepts. It supports algorithms that<\/p>\n To make it short: The ranges library supports functional patterns.<\/p>\n Okay, code may help more than words. The following functions show function composition with the pipe symbol.<\/p>\n even<\/span> is a lambda function that returns if a i is even, and the lambda function square<\/span> maps i to its square. The rest ist function composition, which you have to read from left to right: for (int i : ints | std::view::filter(even) | std::view::transform(square)). <\/span>Apply the filter even on each element of ints and map each remaining element to its square<\/span>. If you are familiar with functional programming, this reads like prose. <\/span><\/p>\n Coroutines are generalized functions that can be suspended and resumed while keeping their state. Coroutines are the usual way to write event-driven applications. An event-driven application can be simulations, games, servers, user interfaces, or even algorithms. Coroutines are also typically used for cooperative multitasking<\/a>.<\/p>\n We don’t get with C++20 concrete coroutines; we will get a framework for writing our coroutines. The framework for writing coroutines consists of more than 20 functions that you partially have to implement and partially could overwrite. Therefore, you can tailor the coroutine to your needs.<\/p>\n Let me show you the usage of a special coroutine. The following program uses a generator for an infinite data stream.<\/p>\n Okay, I have to add a few words. This piece is only a code snippet. The function getNext<\/span> is a coroutine because it uses the keyword co_yield. getNext<\/span> has an infinite loop that returns the value<\/span> after co_yield<\/span>. A call to next()<\/span> (lines 2 and 3) resumes the coroutine, and the following getValue<\/span> call gets the value. After the getNext<\/span> call, the coroutine pauses once more. It pauses until the following next()<\/span> call. There is one big unknown in my example. This unknown is the return value Generator<int><\/span> of the getNext<\/span> function. Here the complicated stuff starts, which will be part of detailed posts to coroutines.<\/p>\n Thanks to the Wandbox online compiler, I can show you the program’s output.<\/p>\n I make modules relatively short because the post is already too long.<\/p>\n Modules promise:<\/p>\n![\"Core\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/10\/Core.PNG\")
<\/p>\n![\"Library\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/10\/Library.PNG\")
<\/p>\n\n
\n<\/span><\/span><\/p>\nThe Big Four<\/h2>\n
Concepts<\/h3>\n
\n
\n
\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\nconcept Integral = std::<\/span>is_integral<<\/span>T>::<\/span>value;\n\nIntegral auto<\/span> gcd(Integral auto<\/span> a, \n Integral auto<\/span> b){\n if<\/span>( b ==<\/span> 0<\/span> ) return<\/span> a; \n else<\/span> return<\/span> gcd<\/span>(b, a %<\/span> b);\n}\n<\/pre>\n<\/div>\n\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\nrequires Integral<<\/span>T><\/span>()\nT gcd(T a, T b){\n if<\/span>( b ==<\/span> 0<\/span> ) return<\/span> a; \n else<\/span> return<\/span> gcd<\/span>(b, a %<\/span> b);\n}\n<\/pre>\n<\/div>\nRanges Library<\/h3>\n
\n
\n#include <vector><\/span>\n#include <ranges><\/span>\n#include <iostream><\/span>\n \nint<\/span> main<\/span>(){\n std::<\/span>vector<<\/span>int<\/span>><\/span> ints{0<\/span>, 1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\n auto<\/span> even =<\/span> [](int<\/span> i){ return<\/span> 0<\/span> ==<\/span> i %<\/span> 2<\/span>; };\n auto<\/span> square =<\/span> [](int<\/span> i) { return<\/span> i *<\/span> i; };\n \n for<\/span> (int<\/span> i :<\/span> ints |<\/span> std::<\/span>view::<\/span>filter(even) |<\/span> \n std::<\/span>view::<\/span>transform(square)) {\n std::<\/span>cout <<<\/span> i <<<\/span> ' '<\/span>; \/\/ 0 4 16<\/span>\n }\n}\n<\/pre>\n<\/div>\nCoroutines<\/h3>\n
\nGenerator<<\/span>int<\/span>><\/span> getNext(int<\/span> start =<\/span> 0<\/span>, int<\/span> step =<\/span> 1<\/span>){\n auto<\/span> value =<\/span> start;\n for<\/span> (int<\/span> i =<\/span> 0<\/span>;; ++<\/span>i){\n co_yield value; \/\/ 1<\/span>\n value +=<\/span> step;\n }\n}\n\nint<\/span> main() {\n \n std::<\/span>cout <<<\/span> std::<\/span>endl;\n \n std::<\/span>cout <<<\/span> \"getNext():\"<\/span>;\n auto<\/span> gen =<\/span> getNext();\n for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <=<\/span> 10<\/span>; ++<\/span>i) {\n gen.next(); \/\/ 2<\/span>\n std::<\/span>cout <<<\/span> \" \"<\/span> <<<\/span> gen.getValue(); \n }\n \n std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n \n std::<\/span>cout <<<\/span> \"getNext(100, -10):\"<\/span>;\n auto<\/span> gen2 =<\/span> getNext(100<\/span>, -<\/span>10<\/span>);\n for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <=<\/span> 20<\/span>; ++<\/span>i) {\n gen2.next(); \/\/ 3<\/span>\n std::<\/span>cout <<<\/span> \" \"<\/span> <<<\/span> gen2.getValue();\n }\n \n std::<\/span>cout <<<\/span> std::<\/span>endl;\n \n}\n<\/pre>\n<\/div>\n![\"infiniteDataStream\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/10\/infiniteDataStream.PNG\")
<\/p>\nModules<\/h3>\n
\n
What’s next?<\/h2>\n