{"id":6300,"date":"2022-02-04T12:26:32","date_gmt":"2022-02-04T12:26:32","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/constexpr-and-consteval-functions-in-c-20\/"},"modified":"2023-06-26T09:15:46","modified_gmt":"2023-06-26T09:15:46","slug":"constexpr-and-consteval-functions-in-c-20","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/constexpr-and-consteval-functions-in-c-20\/","title":{"rendered":"constexpr and consteval Functions in C++20"},"content":{"rendered":"

With C++20, constexpr<\/code> became way more powerful. Additionally, we have  consteval<\/code> functions in C++20 that are quite similar to constexpr<\/code> functions.<\/p>\n

<\/p>\n

 \"constexpr\"<\/p>\n

Let me first describe a feature in C++20 that surprised me the most.<\/p>\n

constexpr<\/code> Containers and Algorithms of the Standard Template Library<\/h2>\n

C++20 supports the constexpr<\/code> containers std::vector<\/code> and std::string<\/code>, where constexpr<\/code> means that the member functions of both containers can be applied at compile time. Additionally, more than
100 classical algorithms of the Standard Template Library<\/a> are declared as constexpr<\/code>. Consequently, you can sort a std::vector<\/code> of ints at compile time.<\/p>\n

Let’s see what this means:<\/p>\n

<\/p>\n

\n
\/\/ constexprVector.cpp<\/span>\r\n\r\n#include <algorithm><\/span>\r\n#include <iostream><\/span>\r\n#include <vector><\/span>\r\n\r\nconstexpr int<\/span> maxElement<\/span>() {\r\n    std::<\/span>vector myVec =<\/span> {1<\/span>, 2<\/span>, 4<\/span>, 3<\/span>};        \/\/ (1)<\/span>\r\n    std::<\/span>sort(myVec.begin(), myVec.end());\r\n    return<\/span> myVec.back();\r\n}\r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span>  '\\n'<\/span>;\r\n\r\n    constexpr int<\/span> maxValue =<\/span> maxElement();\r\n    std::<\/span>cout <<<\/span> \"maxValue: \"<\/span> <<<\/span> maxValue <<<\/span> '\\n'<\/span>;\r\n\r\n    constexpr int<\/span> maxValue2 =<\/span> [] {\r\n        std::<\/span>vector myVec =<\/span> {1<\/span>, 2<\/span>, 4<\/span>, 3<\/span>};    \/\/ (2)<\/span>\r\n        std::<\/span>sort(myVec.begin(), myVec.end()) ;\r\n        return<\/span> myVec.back();\r\n    }(); \r\n\r\n    std::<\/span>cout <<<\/span> \"maxValue2: \"<\/span> <<<\/span> maxValue2 <<<\/span> '\\n'<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The two containers std::vector<\/code> (lines (1) and (2)) are sorted at compile time using constexpr<\/code>-declared functions. In the first case, the function maxElement<\/code> returns the last element of the vector myVec<\/code>, which is its maximum value. In the second case, I use an immediately-invoked lambda that is declared constexpr.<\/code> Here is the output of the program:<\/p>\n
\"constexprVector\"<\/code><\/p>\n
The crucial idea for constexpr<\/code> containers is transient allocation.<\/p>\n<\/p>\n
Transient Allocation<\/h3>\n
Transient allocation means that memory allocated at compile time must also be released at compile time. Consequently, the compiler can detect a function’s mismatch of allocation and deallocation. The following example applies transient allocation.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ transientAllocation.cpp<\/span>\r\n\r\n#include <memory><\/span>\r\n\r\nconstexpr auto<\/span> correctRelease<\/span>() {  \r\n     auto<\/span>*<\/span> p =<\/span> new<\/span> int<\/span>[2020<\/span>];\r\n     delete<\/span> [] p;\r\n     return<\/span> 2020<\/span>;\r\n}\r\n\r\nconstexpr auto<\/span> forgottenRelease<\/span>() { \/\/ (1)<\/span>\r\n    auto<\/span>*<\/span> p =<\/span> new<\/span> int<\/span>[2020<\/span>];  \r\n    return<\/span> 2020<\/span>;\r\n}\r\n\r\nconstexpr auto<\/span> falseRelease<\/span>() {     \/\/ (3)<\/span>\r\n    auto<\/span>*<\/span> p =<\/span> new<\/span> int<\/span>[2020<\/span>];\r\n    delete<\/span> p;                       \/\/ (2)<\/span><\/em>\r\n    return<\/span> 2020<\/span>;\r\n}\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    constexpr int<\/span> res1 =<\/span> correctRelease();\r\n    constexpr int<\/span> res2 =<\/span> forgottenRelease();\r\n    constexpr int<\/span> res3 =<\/span> falseRelease();\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The minor program has two serious issues. First, the memory in the constexpr<\/code> function forgottenRelease<\/code> (line (1)) is not released. Second, the non-array deallocation (line 3) in the constexpr<\/code> function falseRelease<\/code> (line (3)) does not match the array allocation. Consequentially, the compilation fails.<\/p>\n
\"transientAllocation\"<\/p>\n
With C++20, we got consteval<\/code> functions that are pretty similar to contexpr<\/code> functions.<\/p>\n
consteval<\/code> Functions<\/h2>\n
Often developers are irritated because they don’t know if a constexpr<\/code> function is executed at run time or compile time. Let’s consider the following code snippet.<\/p>\n
<\/p>\n
\n
constexpr int<\/span> constexprFunction<\/span>(int<\/span> arg) {\r\n    return<\/span> arg *<\/span> arg;\r\n}\r\n\r\nstatic_assert(constexprFunction(10<\/span>) ==<\/span> 100<\/span>);                     \/\/ (1)<\/span>\r\nint<\/span> arrayNewWithConstExpressiomFunction[constexprFunction(100<\/span>)]; \/\/ (2)<\/span>\r\nconstexpr int<\/span> prod =<\/span> constexprFunction(100<\/span>);                     \/\/ (3)<\/span>\r\n\r\nint<\/span> a =<\/span> 100<\/span>;\r\nint<\/span> runTime =<\/span> constexprFunction(a);                              \/\/ (4)<\/span><\/em>\r\n\r\nint<\/span> runTimeOrCompiletime =<\/span> constexprFunction(100<\/span>);               \/\/ (5)<\/span>\r\n<\/pre>\n<\/div>\n
 <\/p>\n
constexprFunction<\/code> is, as its name suggests, a constexpr<\/code> function.<\/p>\n
    \n
  1. A constexpr function must run at compile time when used in a constexpr<\/code> context, or the result is requested at compile time. line (1) and line (2) are constexpr<\/code> contexts. Line (3), on the contrary, requires the function execution  constexprFuncion<\/code> on compile time.<\/li>\n
  2. The call constexprFunction(a) <\/code> (line 4) must be executed at run time because a is not a constant expression.<\/li>\n
  3. Line 5 is an interesting case. There are no requirements for the function execution. Therefore, the call constexprFunction(100) (line 5) can be executed at run or compile times. From the C++ standard perspective, both are fine.<\/li>\n<\/ol>\n
    In contrast to a constexpr<\/code> function, a consteval<\/code> function can only be executed at compile time.<\/p>\n
    consteval<\/code> creates a so-called immediate function.<\/p>\n
    <\/p>\n
    \n
    consteval int<\/span> sqr<\/span>(int<\/span> n) {\r\n    return<\/span> n *<\/span> n;\r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    Each invocation of an immediate function creates a compile-time constant.  consteval<\/code> cannot be applied to destructors or functions that allocate or deallocate. A consteval<\/code> function is as a constexpr<\/code> function implicitly inline and has to fulfill the requirements for a constexpr<\/code> function.<\/p>\n
    The requirements of a constexpr<\/code> function in C++14 and, therefore, a consteval<\/code> function are:<\/p>\n
      \n
    • A consteval<\/code> (constexpr<\/code>) can\n
        \n
      • have conditional jump instructions or loop instructions.<\/li>\n
      • have more than one instruction.<\/li>\n
      • invoke constexpr functions. A consteval<\/code> function can only invoke a constexpr<\/code> function but not the other way around.<\/li>\n
      • use fundamental data types as variables that must be initialized with a constant expression.<\/li>\n<\/ul>\n<\/li>\n
      • A consteval<\/code> (constexpr<\/code>) function cannot\n
          \n
        • have static or thread_local<\/code> data.<\/li>\n
        • have a try block nor a goto instruction.<\/li>\n
        • invoke or use non-consteval<\/code> functions or non-constexpr<\/code> data.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
          There is one exciting use-case that consteval<\/code> enables. You can initialize a local non-constant variable at compile time.<\/p>\n
           <\/p>\n
          <\/p>\n
          \n
          \/\/ compileTimeInitializationLocal.cpp<\/span>\r\n\r\nconsteval auto<\/span> doubleMe<\/span>(auto<\/span> val) {\r\n  return<\/span> 2<\/span> *<\/span> val;\r\n}\r\n\r\nint<\/span> main<\/span>() {\r\n\r\nauto<\/span> res =<\/span> doubleMe(1010<\/span>);  \/\/ (1)<\/span><\/em>\r\n++<\/span>res;                     \/\/ 2021 (2)<\/span>\r\n\r\n}\r\n<\/pre>\n<\/div>\n
           <\/p>\n
          The local res<\/code> is initialized at compile time (line 1) and modified at run time (line 2). On the contrary, if the function doubleMe<\/code> is declared as constexpr<\/code>, it could be executed at run time.<\/p>\n
          What’s next?<\/h2>\n
          Before I dive into the new topic block design with templates, I want to present in the next post the C++17 feature constexpr if. constexpr if <\/code>enables it to compile source code conditionally and can be used for nice tricks at compile time.<\/p>\n
           <\/p>\n<\/p>\n
           <\/p>\n","protected":false},"excerpt":{"rendered":"
          With C++20, constexpr became way more powerful. Additionally, we have  consteval functions in C++20 that are quite similar to constexpr functions.<\/p>\n","protected":false},"author":21,"featured_media":6297,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[376],"tags":[429,428],"class_list":["post-6300","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-templates","tag-consteval","tag-constexpr"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6300","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=6300"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6300\/revisions"}],"predecessor-version":[{"id":6683,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6300\/revisions\/6683"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6297"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6300"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6300"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6300"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}