# C++20 ## Overview Many of these descriptions and examples are taken from various resources (see [Acknowledgements](#acknowledgements) section) and summarized in my own words. C++20 includes the following new language features: - [coroutines](#coroutines) - [concepts](#concepts) - [three-way comparison](#three-way-comparison) - [designated initializers](#designated-initializers) - [template syntax for lambdas](#template-syntax-for-lambdas) - [range-based for loop with initializer](#range-based-for-loop-with-initializer) - [\[\[likely\]\] and \[\[unlikely\]\] attributes](#likely-and-unlikely-attributes) - [deprecate implicit capture of this](#deprecate-implicit-capture-of-this) - [class types in non-type template parameters](#class-types-in-non-type-template-parameters) - [constexpr virtual functions](#constexpr-virtual-functions) - [explicit(bool)](#explicitbool) - [immediate functions](#immediate-functions) - [using enum](#using-enum) - [lambda capture of parameter pack](#lambda-capture-of-parameter-pack) - [char8_t](#char8_t) - [constinit](#constinit) - [\_\_VA\_OPT\_\_](#__VA_OPT__) C++20 includes the following new library features: - [concepts library](#concepts-library) - [formatting library](#formatting-library) - [synchronized buffered outputstream](#synchronized-buffered-outputstream) - [std::span](#stdspan) - [bit operations](#bit-operations) - [math constants](#math-constants) - [std::is_constant_evaluated](#stdis_constant_evaluated) - [std::make_shared supports arrays](#stdmake_shared-supports-arrays) - [starts_with and ends_with on strings](#starts_with-and-ends_with-on-strings) - [check if associative container has element](#check-if-associative-container-has-element) - [std::bit_cast](#stdbit_cast) - [std::midpoint](#stdmidpoint) - [std::to_array](#stdto_array) - [std::bind_front](#stdbind_front) - [uniform container erasure](#uniform-container-erasure) - [three-way comparison helpers](#three-way-comparison-helpers) - [std::lexicographical_compare_three_way](#stdlexicographical_compare_three_way) ## C++20 Language Features ### Coroutines > **Note:** While these examples illustrate how to use coroutines at a basic level, there is lots more going on when the code is compiled. These examples are not meant to be complete coverage of C++20's coroutines. Since the `generator` and `task` classes are not provided by the standard library yet, I used the cppcoro library to compile these examples. _Coroutines_ are special functions that can have their execution suspended and resumed. To define a coroutine, the `co_return`, `co_await`, or `co_yield` keywords must be present in the function's body. C++20's coroutines are stackless; unless optimized out by the compiler, their state is allocated on the heap. An example of a coroutine is a _generator_ function, which yields (i.e. generates) a value at each invocation: ```c++ generator range(int start, int end) { while (start < end) { co_yield start; start++; } // Implicit co_return at the end of this function: // co_return; } for (int n : range(0, 10)) { std::cout << n << std::endl; } ``` The above `range` generator function generates values starting at `start` until `end` (exclusive), with each iteration step yielding the current value stored in `start`. The generator maintains its state across each invocation of `range` (in this case, the invocation is for each iteration in the for loop). `co_yield` takes the given expression, yields (i.e. returns) its value, and suspends the coroutine at that point. Upon resuming, execution continues after the `co_yield`. Another example of a coroutine is a _task_, which is an asynchronous computation that is executed when the task is awaited: ```c++ task echo(socket s) { for (;;) { auto data = co_await s.async_read(); co_await async_write(s, data); } // Implicit co_return at the end of this function: // co_return; } ``` In this example, the `co_await` keyword is introduced. This keyword takes an expression and suspends execution if the thing you're awaiting on (in this case, the read or write) is not ready, otherwise you continue execution. (Note that under the hood, `co_yield` uses `co_await`.) Using a task to lazily evaluate a value: ```c++ task calculate_meaning_of_life() { co_return 42; } auto meaning_of_life = calculate_meaning_of_life(); // ... co_await meaning_of_life; // == 42 ``` ### Concepts _Concepts_ are named compile-time predicates which constrain types. They take the following form: ``` template < template-parameter-list > concept concept-name = constraint-expression; ``` where `constraint-expression` evaluates to a constexpr Boolean. _Constraints_ should model semantic requirements, such as whether a type is a numeric or hashable. A compiler error results if a given type does not satisfy the concept it's bound by (i.e. `constraint-expression` returns `false`). Because constraints are evaluated at compile-time, they can provide more meaningful error messages and runtime safety. ```c++ // `T` is not limited by any constraints. template concept always_satisfied = true; // Limit `T` to integrals. template concept integral = std::is_integral_v; // Limit `T` to both the `integral` constraint and signedness. template concept signed_integral = integral && std::is_signed_v; // Limit `T` to both the `integral` constraint and the negation of the `signed_integral` constraint. template concept unsigned_integral = integral && !signed_integral; ``` There are a variety of syntactic forms for enforcing concepts: ```c++ // Forms for function parameters: // `T` is a constrained type template parameter. template void f(T v); // `T` is a constrained type template parameter. template requires my_concept void f(T v); // `T` is a constrained type template parameter. template void f(T v) requires my_concept; // `v` is a constrained deduced parameter. void f(my_concept auto v); // `v` is a constrained non-type template parameter. template void g(); // Forms for auto-deduced variables: // `foo` is a constrained auto-deduced value. my_concept auto foo = ...; // Forms for lambdas: // `T` is a constrained type template parameter. auto f = [] (T v) { // ... }; // `T` is a constrained type template parameter. auto f = [] requires my_concept (T v) { // ... }; // `T` is a constrained type template parameter. auto f = [] (T v) requires my_concept { // ... }; // `v` is a constrained deduced parameter. auto f = [](my_concept auto v) { // ... }; // `v` is a constrained non-type template parameter. auto g = [] () { // ... }; ``` The `requires` keyword is used either to start a `requires` clause or a `requires` expression: ```c++ template requires my_concept // `requires` clause. void f(T); template concept callable = requires (T f) { f(); }; // `requires` expression. template requires requires (T x) { x + x; } // `requires` clause and expression on same line. T add(T a, T b) { return a + b; } ``` Note that the parameter list in a `requires` expression is optional. Each requirement in a `requires` expression are one of the following: * **Simple requirements** - asserts that the given expression is valid. ```c++ template concept callable = requires (T f) { f(); }; ``` * **Type requirements** - denoted by the `typename` keyword followed by a type name, asserts that the given type name is valid. ```c++ struct foo { int foo; }; struct bar { using value = int; value data; }; struct baz { using value = int; value data; }; // Using SFINAE, enable if `T` is a `baz`. template >> struct S {}; template using Ref = T&; template concept C = requires { // Requirements on type `T`: typename T::value; // A) has an inner member named `value` typename S; // B) must have a valid class template specialization for `S` typename Ref; // C) must be a valid alias template substitution }; template void g(T a); g(foo{}); // ERROR: Fails requirement A. g(bar{}); // ERROR: Fails requirement B. g(baz{}); // PASS. ``` * **Compound requirements** - an expression in braces followed by a trailing return type or type constraint. ```c++ template concept C = requires(T x) { {*x} -> std::convertible_to; // the type of the expression `*x` is convertible to `T::inner` {x + 1} -> std::same_as; // the expression `x + 1` satisfies `std::same_as` {x * 1} -> std::convertible_to; // the type of the expression `x * 1` is convertible to `T` }; ``` * **Nested requirements** - denoted by the `requires` keyword, specify additional constraints (such as those on local parameter arguments). ```c++ template concept C = requires(T x) { requires std::same_as; }; ``` See also: [concepts library](#concepts-library). ### Three-way comparison C++20 introduces the spaceship operator (`<=>`) as a new way to write comparison functions that reduce boilerplate and help developers define clearer comparison semantics. Defining a three-way comparison operator will autogenerate the other comparison operator functions (i.e. `==`, `!=`, `<`, etc.). Three orderings are introduced: * `std::strong_ordering`: The strong ordering distinguishes between items being equal (identical and interchangeable). Provides `less`, `greater`, `equivalent`, and `equal` ordering. Examples of comparisons: searching for a specific value in a list, values of integers, case-sensitive strings. * `std::weak_ordering`: The weak ordering distinguishes between items being equivalent (not identical, but can be interchangeable for the purposes of comparison). Provides `less`, `greater`, and `equivalent` ordering. Examples of comparisons: case-insensitive strings, sorting, comparing some but not all visible members of a class. * `std::partial_ordering`: The partial ordering follows the same principle of weak ordering but includes the case when an ordering isn't possible. Provides `less`, `greater`, `equivalent`, and `unordered` ordering. Examples of comparisons: floating-point values (e.g. `NaN`). A defaulted three-way comparison operator does a member-wise comparison: ```c++ struct foo { int a; bool b; char c; // Compare `a` first, then `b`, then `c` ... auto operator<=>(const foo&) const = default; }; foo f1{0, false, 'a'}, f2{0, true, 'b'}; f1 < f2; // == true f1 == f2; // == false f1 >= f2; // == false ``` You can also define your own comparisons: ```c++ struct foo { int x; bool b; char c; std::strong_ordering operator<=>(const foo& other) const { return x <=> other.x; } }; foo f1{0, false, 'a'}, f2{0, true, 'b'}; f1 < f2; // == false f1 == f2; // == true f1 >= f2; // == true ``` ### Designated initializers C-style designated initializer syntax. Any member fields that are not explicitly listed in the designated initializer list are default-initialized. ```c++ struct A { int x; int y; int z = 123; }; A a {.x = 1, .z = 2}; // a.x == 1, a.y == 0, a.z == 2 ``` ### Template syntax for lambdas Use familiar template syntax in lambda expressions. ```c++ auto f = [](std::vector v) { // ... }; ``` ### Range-based for loop with initializer This feature simplifies common code patterns, helps keep scopes tight, and offers an elegant solution to a common lifetime problem. ```c++ for (auto v = std::vector{1, 2, 3}; auto& e : v) { std::cout << e; } // prints "123" ``` ### \[\[likely\]\] and \[\[unlikely\]\] attributes Provides a hint to the optimizer that the labelled statement has a high probability of being executed. ```c++ switch (n) { case 1: // ... break; [[likely]] case 2: // n == 2 is considered to be arbitrarily more // ... // likely than any other value of n break; } ``` If one of the likely/unlikely attributes appears after the right parenthesis of an if-statement, it indicates that the branch is likely/unlikely to have its substatement (body) executed. ```c++ int random = get_random_number_between_x_and_y(0, 3); if (random > 0) [[likely]] { // body of if statement // ... } ``` It can also be applied to the substatement (body) of an iteration statement. ```c++ while (unlikely_truthy_condition) [[unlikely]] { // body of while statement // ... } ``` ### Deprecate implicit capture of this Implicitly capturing `this` in a lambda capture using `[=]` is now deprecated; prefer capturing explicitly using `[=, this]` or `[=, *this]`. ```c++ struct int_value { int n = 0; auto getter_fn() { // BAD: // return [=]() { return n; }; // GOOD: return [=, *this]() { return n; }; } }; ``` ### Class types in non-type template parameters Classes can now be used in non-type template parameters. Objects passed in as template arguments have the type `const T`, where `T` is the type of the object, and has static storage duration. ```c++ struct foo { foo() = default; constexpr foo(int) {} }; template auto get_foo() { return f; } get_foo(); // uses implicit constructor get_foo(); ``` ### constexpr virtual functions Virtual functions can now be `constexpr` and evaluated at compile-time. `constexpr` virtual functions can override non-`constexpr` virtual functions and vice-versa. ```c++ struct X1 { virtual int f() const = 0; }; struct X2: public X1 { constexpr virtual int f() const { return 2; } }; struct X3: public X2 { virtual int f() const { return 3; } }; struct X4: public X3 { constexpr virtual int f() const { return 4; } }; constexpr X4 x4; x4.f(); // == 4 ``` ### explicit(bool) Conditionally select at compile-time whether a constructor is made explicit or not. `explicit(true)` is the same as specifying `explicit`. ```c++ struct foo { // Specify non-integral types (strings, floats, etc.) require explicit construction. template explicit(!std::is_integral_v) foo(T) {} }; foo a = 123; // OK foo b = "123"; // ERROR: explicit constructor is not a candidate (explicit specifier evaluates to true) foo c {"123"}; // OK ``` ### Immediate functions Similar to `constexpr` functions, but functions with a `consteval` specifier must produce a constant. These are called `immediate functions`. ```c++ consteval int sqr(int n) { return n * n; } constexpr int r = sqr(100); // OK int x = 100; int r2 = sqr(x); // ERROR: the value of 'x' is not usable in a constant expression // OK if `sqr` were a `constexpr` function ``` ### using enum Bring an enum's members into scope to improve readability. Before: ```c++ enum class rgba_color_channel { red, green, blue, alpha }; std::string_view to_string(rgba_color_channel channel) { switch (channel) { case rgba_color_channel::red: return "red"; case rgba_color_channel::green: return "green"; case rgba_color_channel::blue: return "blue"; case rgba_color_channel::alpha: return "alpha"; } } ``` After: ```c++ enum class rgba_color_channel { red, green, blue, alpha }; std::string_view to_string(rgba_color_channel my_channel) { switch (my_channel) { using enum rgba_color_channel; case red: return "red"; case green: return "green"; case blue: return "blue"; case alpha: return "alpha"; } } ``` ### Lambda capture of parameter pack Capture parameter packs by value: ```c++ template auto f(Args&&... args){ // BY VALUE: return [...args = std::forward(args)] { // ... }; } ``` Capture parameter packs by reference: ```c++ template auto f(Args&&... args){ // BY REFERENCE: return [&...args = std::forward(args)] { // ... }; } ``` ### char8_t Provides a standard type for representing UTF-8 strings. ```c++ char8_t utf8_str[] = u8"\u0123"; ``` ### constinit The `constinit` specifier requires that a variable must be initialized at compile-time. ```c++ const char* g() { return "dynamic initialization"; } constexpr const char* f(bool p) { return p ? "constant initializer" : g(); } constinit const char* c = f(true); // OK constinit const char* d = g(false); // ERROR: `g` is not constexpr, so `d` cannot be evaluated at compile-time. ``` ### \_\_VA\_OPT\_\_ Helps support variadic macros by evaluating to the given argument if the variadic macro is non-empty. ```c++ #define F(...) f(0 __VA_OPT__(,) __VA_ARGS__) F(a, b, c) // replaced by f(0, a, b, c) F() // replaced by f(0) ``` ## C++20 Library Features ### Concepts library Concepts are also provided by the standard library for building more complicated concepts. Some of these include: **Core language concepts:** - `same_as` - specifies two types are the same. - `derived_from` - specifies that a type is derived from another type. - `convertible_to` - specifies that a type is implicitly convertible to another type. - `common_with` - specifies that two types share a common type. - `integral` - specifies that a type is an integral type. - `default_constructible` - specifies that an object of a type can be default-constructed. **Comparison concepts:** - `boolean` - specifies that a type can be used in Boolean contexts. - `equality_comparable` - specifies that `operator==` is an equivalence relation. **Object concepts:** - `movable` - specifies that an object of a type can be moved and swapped. - `copyable` - specifies that an object of a type can be copied, moved, and swapped. - `semiregular` - specifies that an object of a type can be copied, moved, swapped, and default constructed. - `regular` - specifies that a type is _regular_, that is, it is both `semiregular` and `equality_comparable`. **Callable concepts:** - `invocable` - specifies that a callable type can be invoked with a given set of argument types. - `predicate` - specifies that a callable type is a Boolean predicate. See also: [concepts](#concepts). ### Formatting library Combine the simplicity of `printf` with the type-safety of `iostream`. Uses braces as placeholders, and supports custom formatting similar to printf-style specifiers. ```c++ std::format("{1} {0}", "world", "hello"); // == "hello world" int x = 123; std::string str = std::format("x: {}", x); // str == "x: 123" // Format to an output iterator: for (auto x : {1, 2, 3}) { std::format_to(std::ostream_iterator{std::cout, "\n"}, "{}", x); } ``` To format custom types: ```c++ struct fraction { int numerator; int denominator; }; template <> struct std::formatter { constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); } auto format(const fraction& f, std::format_context& ctx) const { return std::format_to(ctx.out(), "{0:d}/{1:d}", f.numerator, f.denominator); } }; fraction f{1, 2}; std::format("{}", f); // == "1/2" ``` ### Synchronized buffered outputstream Buffers output operations for the wrapped output stream ensuring synchronization (i.e. no interleaving of output). ```c++ std::osyncstream{std::cout} << "The value of x is:" << x << std::endl; ``` ### std::span A span is a view (i.e. non-owning) of a container providing bounds-checked access to a contiguous group of elements. Since views do not own their elements they are cheap to construct and copy -- a simplified way to think about views is they are holding references to their data. As opposed to maintaining a pointer/iterator and length field, a span wraps both of those up in a single object. Spans can be dynamically-sized or fixed-sized (known as their *extent*). Fixed-sized spans benefit from bounds-checking. Span doesn't propogate const so to construct a read-only span use `std::span`. Example: using a dynamically-sized span to print integers from various containers. ```c++ void print_ints(std::span ints) { for (const auto n : ints) { std::cout << n << std::endl; } } print_ints(std::vector{ 1, 2, 3 }); print_ints(std::array{ 1, 2, 3, 4, 5 }); int a[10] = { 0 }; print_ints(a); // etc. ``` Example: a statically-sized span will fail to compile for containers that don't match the extent of the span. ```c++ void print_three_ints(std::span ints) { for (const auto n : ints) { std::cout << n << std::endl; } } print_three_ints(std::vector{ 1, 2, 3 }); // ERROR print_three_ints(std::array{ 1, 2, 3, 4, 5 }); // ERROR int a[10] = { 0 }; print_three_ints(a); // ERROR std::array b = { 1, 2, 3 }; print_three_ints(b); // OK // You can construct a span manually if required: std::vector c{ 1, 2, 3 }; print_three_ints(std::span{ c.data(), 3 }); // OK: set pointer and length field. print_three_ints(std::span{ c.cbegin(), c.cend() }); // OK: use iterator pairs. ``` ### Bit operations C++20 provides a new `` header which provides some bit operations including popcount. ```c++ std::popcount(0u); // 0 std::popcount(1u); // 1 std::popcount(0b1111'0000u); // 4 ``` ### Math constants Mathematical constants including PI, Euler's number, etc. defined in the `` header. ```c++ std::numbers::pi; // 3.14159... std::numbers::e; // 2.71828... ``` ### std::is_constant_evaluated Predicate function which is truthy when it is called in a compile-time context. ```c++ constexpr bool is_compile_time() { return std::is_constant_evaluated(); } constexpr bool a = is_compile_time(); // true bool b = is_compile_time(); // false ``` ### std::make_shared supports arrays ```c++ auto p = std::make_shared(5); // pointer to `int[5]` // OR auto p = std::make_shared(); // pointer to `int[5]` ``` ### starts_with and ends_with on strings Strings (and string views) now have the `starts_with` and `ends_with` member functions to check if a string starts or ends with the given string. ```c++ std::string str = "foobar"; str.starts_with("foo"); // true str.ends_with("baz"); // false ``` ### Check if associative container has element Associative containers such as sets and maps have a `contains` member function, which can be used instead of the "find and check end of iterator" idiom. ```c++ std::map map {{1, 'a'}, {2, 'b'}}; map.contains(2); // true map.contains(123); // false std::set set {1, 2, 3}; set.contains(2); // true ``` ### std::bit_cast A safer way to reinterpret an object from one type to another. ```c++ float f = 123.0; int i = std::bit_cast(f); ``` ### std::midpoint Calculate the midpoint of two integers safely (without overflow). ```c++ std::midpoint(1, 3); // == 2 ``` ### std::to_array Converts the given array/"array-like" object to a `std::array`. ```c++ std::to_array("foo"); // returns `std::array` std::to_array({1, 2, 3}); // returns `std::array` int a[] = {1, 2, 3}; std::to_array(a); // returns `std::array` ``` ### std::bind_front Binds the first N arguments (where N is the number of arguments after the given function to `std::bind_front`) to a given free function, lambda, or member function. ```c++ const auto f = [](int a, int b, int c) { return a + b + c; }; const auto g = std::bind_front(f, 1, 1); g(1); // == 3 ``` ### Uniform container erasure Provides `std::erase` and/or `std::erase_if` for a variety of STL containers such as string, list, vector, map, etc. For erasing by value use `std::erase`, or to specify a predicate when to erase elements use `std::erase_if`. Both functions return the number of erased elements. ```c++ std::vector v{0, 1, 0, 2, 0, 3}; std::erase(v, 0); // v == {1, 2, 3} std::erase_if(v, [](int n) { return n == 0; }); // v == {1, 2, 3} ``` ### Three-way comparison helpers Helper functions for giving names to comparison results: ```c++ std::is_eq(0 <=> 0); // == true std::is_lteq(0 <=> 1); // == true std::is_gt(0 <=> 1); // == false ``` See also: [three-way comparison](#three-way-comparison). ### std::lexicographical_compare_three_way Lexicographically compares two ranges using three-way comparison and produces a result of the strongest applicable comparison category type. ```c++ std::vector a{0, 0, 0}, b{0, 0, 0}, c{1, 1, 1}; auto cmp_ab = std::lexicographical_compare_three_way( a.begin(), a.end(), b.begin(), b.end()); std::is_eq(cmp_ab); // == true auto cmp_ac = std::lexicographical_compare_three_way( a.begin(), a.end(), c.begin(), c.end()); std::is_lt(cmp_ac); // == true ``` See also: [three-way comparison](#three-way-comparison), [three-way comparison helpers](#three-way-comparison-helpers). ## Acknowledgements * [cppreference](http://en.cppreference.com/w/cpp) - especially useful for finding examples and documentation of new library features. * [C++ Rvalue References Explained](http://web.archive.org/web/20240324121501/http://thbecker.net/articles/rvalue_references/section_01.html) - a great introduction I used to understand rvalue references, perfect forwarding, and move semantics. * [clang](http://clang.llvm.org/cxx_status.html) and [gcc](https://gcc.gnu.org/projects/cxx-status.html)'s standards support pages. Also included here are the proposals for language/library features that I used to help find a description of, what it's meant to fix, and some examples. * [Compiler explorer](https://godbolt.org/) * [Scott Meyers' Effective Modern C++](https://www.amazon.com/Effective-Modern-Specific-Ways-Improve/dp/1491903996) - highly recommended book! * [Jason Turner's C++ Weekly](https://www.youtube.com/channel/UCxHAlbZQNFU2LgEtiqd2Maw) - nice collection of C++-related videos. * [What can I do with a moved-from object?](http://stackoverflow.com/questions/7027523/what-can-i-do-with-a-moved-from-object) * [What are some uses of decltype(auto)?](http://stackoverflow.com/questions/24109737/what-are-some-uses-of-decltypeauto) * And many more SO posts I'm forgetting... ## Author Anthony Calandra ## Content Contributors See: https://github.com/AnthonyCalandra/modern-cpp-features/graphs/contributors ## License MIT