{"id":7848,"date":"2023-07-31T06:46:29","date_gmt":"2023-07-31T06:46:29","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=7848"},"modified":"2023-08-23T17:00:28","modified_gmt":"2023-08-23T17:00:28","slug":"c23-the-small-pearls-in-the-core-language","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c23-the-small-pearls-in-the-core-language\/","title":{"rendered":"C++23: The Small Pearls in the Core Language"},"content":{"rendered":"\n

The C++23 core language has more to offer than deducing this. Today, I will write about the small pearls.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

Literal Suffixes<\/h2>\n\n\n\n

C++23 provides new integral literal suffixes for (signed) std::size_t<\/code>:<\/p>\n\n\n\n

Literal Suffix<\/strong><\/td>Type<\/strong><\/td>Example<\/strong><\/td><\/tr>
z<\/code> or Z<\/code><\/td>signed std::size_t<\/code><\/td>auto signed = -2023z;<\/code><\/td><\/tr>
z\/Z <\/code>and u\/U<\/code><\/td>std::size_t<\/code><\/td>auto unsigned = 2023uz,<\/td><\/tr><\/tbody><\/table>
std::size_t<\/a> (C++17) is an unsigned data type that can hold the maximum size of any type. It is commonly used for array indexing and loop counting. <\/figcaption><\/figure>\n\n\n\n

Let me start with a simple example to see the value of the new suffixes.<\/p>\n\n\n\n

Assume you want to iterate through a vector. For optimization reasons, you cache the vectors’ size. <\/p>\n\n\n\n

#include <vector><\/span>\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>vector<<\/span>int<\/span>><\/span> v{0<\/span>, 1<\/span>, 2<\/span>, 3<\/span>};\n    for<\/span> (auto<\/span> i =<\/span> 0<\/span>, s =<\/span> v.size(); i <<\/span> s; ++<\/span>i) {\n\t    \/* use both i and v[i] *\/<\/span>\n    }\n}\n<\/pre><\/div>\n\n\n\n
When you compile the code, you get the following error message in the Compiler Explorer<\/a>:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
The reason is that auto <\/code>deduced i<\/code> to int <\/code>and s<\/code> to long unsigned int<\/code>. Consequentially, making both variables unsigned will also not fix the issue.<\/p>\n\n\n\n
#include <vector><\/span>\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>vector<<\/span>int<\/span>><\/span> v{0<\/span>, 1<\/span>, 2<\/span>, 3<\/span>};\n    for<\/span> (auto<\/span> i =<\/span> 0u<\/span>, s =<\/span> v.size(); i <<\/span> s; ++<\/span>i) {\n\t    \/* use both i and v[i] *\/<\/span>\n    }\n}\n<\/pre><\/div>\n\n\n\n
Now, the compiler deduces i<\/code> to unsigned int <\/code>but s<\/code> still to long unsigned int<\/code>.  The following screenshot shows the Compiler Explorers<\/a> error output once more.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Thanks to C++23, the new literal suffix z <\/code>will fix this issue.<\/p>\n\n\n\n
#include <vector><\/span>\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>vector<<\/span>int<\/span>><\/span> v{0<\/span>, 1<\/span>, 2<\/span>, 3<\/span>};\n    for<\/span> (auto<\/span> i =<\/span> 0u<\/span>z, s =<\/span> v.size(); i <<\/span> s; ++<\/span>i) {\n\t    \/* use both i and v[i] *\/<\/span>\n    }\n}\n<\/pre><\/div>\n\n\n\n
if consteval<\/code><\/h2>\n\n\n\n
if consteva<\/code>l behaves like if (std::is_constant_evaluated()) { }<\/code> but has a  few advantages:<\/p>\n\n\n\n
    \n
  1. No header <type_traits><\/code> is required.<\/li>\n\n\n\n
  2. Has a more straightforward syntax like std::is_constant_evaluated<\/code>.<\/li>\n\n\n\n
  3. Can be used to invoke an immediate function.<\/li>\n<\/ol>\n\n\n\n
    Let me add a few words. std::is_constant_evaluated<\/code> is a C++20 feature that detects if a constexpr <\/code>function is evaluated during compile time.<\/p>\n\n\n\n
    cppreference.com\/is_constant_evaluated<\/a> has an excellent example: <\/p>\n\n\n\n
    #include <cmath><\/span>\n#include <iostream><\/span>\n#include <type_traits><\/span>\n \nconstexpr double<\/span> power<\/span>(double<\/span> b, int<\/span> x)\n{\n    if<\/span> (std::<\/span>is_constant_evaluated() &&<\/span> !<\/span>(b ==<\/span> 0.0<\/span> &&<\/span> x <<\/span> 0<\/span>))\n    {\n        \/\/ A constant-evaluation context: Use a constexpr-friendly algorithm.<\/span>\n        if<\/span> (x ==<\/span> 0<\/span>)\n            return<\/span> 1.0<\/span>;\n        double<\/span> r {1.0<\/span>};\n        double<\/span> p {x ><\/span> 0<\/span> ?<\/span> b :<\/span> 1.0<\/span> \/<\/span> b};\n        for<\/span> (auto<\/span> u =<\/span> unsigned<\/span>(x ><\/span> 0<\/span> ?<\/span> x :<\/span> -<\/span>x); u !=<\/span> 0<\/span>; u \/=<\/span> 2<\/span>)\n        {\n            if<\/span> (u &<\/span> 1<\/span>)\n                r *=<\/span> p;\n            p *=<\/span> p;\n        }\n        return<\/span> r;\n    }\n    else<\/span>\n    {\n        \/\/ Let the code generator figure it out.<\/span>\n        return<\/span> std::<\/span>pow(b, double<\/span>(x));\n    }\n}\n \nint<\/span> main<\/span>()\n{\n    \/\/ A constant-expression context<\/span>\n    constexpr double<\/span> kilo =<\/span> power(10.0<\/span>, 3<\/span>);\n    int<\/span> n =<\/span> 3<\/span>;\n    \/\/ Not a constant expression, because n cannot be converted to an rvalue<\/span>\n    \/\/ in a constant-expression context<\/span>\n    \/\/ Equivalent to std::pow(10.0, double(n))<\/span>\n    double<\/span> mucho =<\/span> power(10.0<\/span>, n);\n \n    std::<\/span>cout <<<\/span> kilo <<<\/span> " "<\/span> <<<\/span> mucho <<<\/span> "<\/span>\\n<\/span>"<\/span>; \/\/ (3)<\/span>\n}\n<\/pre><\/div>\n\n\n\n
    The function power<\/code> is constexpr<\/code>. This means it has the potential to run at compile time. The first call of power <\/code>causes a compile-time execution because the result is requested at compile-time: constexpr double kilo = power(10.0, 1)<\/code>. On the contrary, the second call can only be performed at run time because the function argument n<\/code> is no constant expression:  double mucho = power(10.0, n<\/code>).<\/p>\n\n\n\n
    Thanks to std::is_constant_evaluated<\/code>, different code is performed at compile time and run time. At compile time, it’s if <\/code>branch is performed, and at run time, it’s else <\/code>branch. Both power <\/code>calls return 1000.<\/p>\n\n\n\n
    An immediate function is a consteval <\/code>function. A consteval <\/code>function is a function that can only run at compile time. You can read more about consteval <\/code>functions in my C++20 post: Two new Keywords in C++20: consteval and constinit<\/a>.<\/p>\n\n\n\n
    Based on consteval if<\/code>, you can implement std::is_constant_evaluated<\/code>: <\/p>\n\n\n\n
    constexpr bool<\/span> is_constant_evaluated<\/span>() {\n    if<\/span> consteval {\n        return<\/span> true<\/span>;\n    } else<\/span> {\n        return<\/span> false<\/span>;\n    }\n}\n<\/pre><\/div>\n\n\n\n
    <\/p>\n\n\n\n
    auto(x) and auto{x}<\/code><\/h2>\n\n\n\n
    A generic way to obtain a copy of an object in C++ is auto copy = x;<\/code>. This is fine but has one issue: copy <\/code>is an lvalue, but you sometimes want a prvalue. prvalue is short for pure rvalue. A pure rvalue is an expression whose evaluation initializes an object. Read Barry’s post: Value Categories in C++17<\/a>, to learn more about value categories.<\/p>\n\n\n\n
    The calls auto(x) <\/code>and auto{x}<\/code> cast x<\/code> into a prvalue as if passing x<\/code> as a function argument by value. auto(x)<\/code> and auto{x}<\/code> perform a decay copy. What?  <\/p>\n\n\n\n
    I often have the question in my class about what decay means. Therefore, let me elaborate on this. Decay essentially means that some type information is lost when you copy a value. A typical example is a function taking its argument by value. Here are the flavors of decay:<\/p>\n\n\n\n
      \n
    1. Array-to-Pointer conversion<\/li>\n\n\n\n
    2. Function-to-Pointer conversion<\/li>\n\n\n\n
    3. Discarding const\/volatile qualifiers<\/li>\n\n\n\n
    4. Removing references <\/li>\n<\/ol>\n\n\n\n
      The following program shows the four flavors of decay:<\/p>\n\n\n\n
      \/\/ decay.cpp<\/span>\n\nvoid<\/span> decay<\/span>(int<\/span>*<\/span>, void<\/span>(*<\/span>)(int<\/span>), int<\/span>, int<\/span> ) { }      \/\/ (5)<\/span>\n\nvoid<\/span> func<\/span>(int<\/span>){}                                   \/\/ (2)<\/span>\n\nint<\/span> main<\/span>() {\n\n    int<\/span> intArray[5<\/span>]{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};                \/\/ (1)<\/span>\n    const<\/span> int<\/span> myInt{5<\/span>};                            \/\/ (3)<\/span>\n    const<\/span> int<\/span>&<\/span> myIntRef =<\/span> myInt;                   \/\/ (4)<\/span>\n\n    decay(intArray, func, myInt, myIntRef);       \n\n}\n<\/pre><\/div>\n\n\n\n
      The function decay <\/code>(5) requires a pointer to an int<\/code>, a function pointer, and two int<\/code>s. The first argument of the function call is an int <\/code>array (1), the second a function (2), the third a const int<\/code> (3), and the last is a const int&<\/code> (4). <\/p>\n\n\n\n
      The type-traits library has the function std::decay<\/a><\/code>. This function enables you to apply these decay conversions directly on a type. Accordingly, these are the corresponding decay conversions using std::decay<\/code>.<\/p>\n\n\n\n
      \/\/ decayType.cpp<\/span>\n\n#include <type_traits><\/span>\n\nint<\/span> main<\/span>() {\n     \n    \/\/ (1)<\/span>\n    \/\/ int[5] -> int* <\/span>\n    static_assert(std::<\/span>is_same<<\/span>std::<\/span>decay<<\/span>int<\/span>[5<\/span>]>::<\/span>type, int<\/span>*>::<\/span>value);             \n    \n    \/\/ (2)<\/span>\n    \/\/ void(int) -> void(*)(int)<\/span>\n    static_assert(std::<\/span>is_same<<\/span>std::<\/span>decay<<\/span>void<\/span>(int<\/span>)>::<\/span>type, void<\/span>(*<\/span>)(int<\/span>)>::<\/span>value);  \n    \n    \/\/ (3)<\/span>\n    \/\/ const int -> int<\/span>\n    static_assert(std::<\/span>is_same<<\/span>std::<\/span>decay<<\/span>const<\/span> int<\/span>>::<\/span>type, int<\/span>>::<\/span>value);           \n    \n    \/\/ (4)<\/span>\n    \/\/ const int& -> int<\/span>\n    static_assert(std::<\/span>is_same<<\/span>std::<\/span>decay<<\/span>const<\/span> int<\/span>&>::<\/span>type, int<\/span>>::<\/span>value);          \n\n}\n<\/pre><\/div>\n\n\n\n
      What’s next? <\/h2>\n\n\n\n
      I’m not done with the small pearls in C++23. In my next post, I will continue my journey with C++23 core language features.<\/p>\n\n\n\n
      <\/p>\n","protected":false},"excerpt":{"rendered":"
      The C++23 core language has more to offer than deducing this. Today, I will write about the small pearls. Literal Suffixes C++23 provides new integral literal suffixes for (signed) std::size_t: Literal Suffix Type Example z or Z signed std::size_t auto signed = -2023z; z\/Z and u\/U std::size_t auto unsigned = 2023uz, std::size_t (C++17) is an […]<\/p>\n","protected":false},"author":21,"featured_media":7888,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[378],"tags":[436],"class_list":["post-7848","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-23","tag-auto"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/7848","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=7848"}],"version-history":[{"count":42,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/7848\/revisions"}],"predecessor-version":[{"id":8035,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/7848\/revisions\/8035"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/7888"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=7848"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=7848"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=7848"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
This example is based on the proposal P0330R8<\/a>. The proposal has more motivating examples for the new literal suffixes.<\/p>\n\n\n\n