{"id":5989,"date":"2020-09-16T20:48:47","date_gmt":"2020-09-16T20:48:47","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/constexpr-vector-and-string-in-c-20\/"},"modified":"2023-06-26T09:44:55","modified_gmt":"2023-06-26T09:44:55","slug":"constexpr-vector-and-string-in-c-20","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/constexpr-vector-and-string-in-c-20\/","title":{"rendered":"constexpr std::vector and std::string in C++20"},"content":{"rendered":"

Probably the most viral keyword in modern C++ is constexpr<\/code>. With C++20, we have a constexpr std::vector<\/code> and a constexpr std::string<\/code>. Additionally, both containers can be manipulated with the constexpr<\/code> algorithms of the Standard Template Library. <\/p>\n

<\/p>\n

 <\/p>\n

\"TimelineCpp20CoreLanguage\"<\/p>\n

In this post, I want to calculate a few numbers’ sum and product at compile time. Depending on the applied C++ standard, this is challenging or quite comfortable to achieve. Let’s start with C++11.<\/p>\n

Variadic Templates in C++11<\/h2>\n

A variadic template is a template that can be invoked with an arbitrary number of arguments. By using the ellipse (…) tails<\/code> becomes a so-called parameter pack. Parameter packs can only be packed and unpacked. If the ellipse is left from tails<\/code>, the parameter pack is packed. If the ellipse is right from tails<\/code>, the parameter pack is unpacked. <\/p>\n

 <\/p>\n

\n
\/\/ compiletimeVariadicTemplates.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span><<\/span>int<\/span>...><\/span>\r\nstruct<\/span> sum;\r\n\r\ntemplate<\/span><><\/span>\r\nstruct<\/span> sum<><\/span> {\r\n  static<\/span> constexpr int<\/span> value =<\/span> 0<\/span>;\r\n};\r\n\r\ntemplate<\/span><<\/span>int<\/span> i, int<\/span>... tail><\/span>\r\nstruct<\/span> sum<<\/span>i, tail...><\/span> {\r\n  static<\/span> constexpr int<\/span> value =<\/span> i +<\/span> sum<<\/span>tail...>::<\/span>value;\r\n};\r\n\r\ntemplate<\/span><<\/span>int<\/span>...>                                  \/\/ (1)<\/span><\/span>\r\nstruct<\/span> product;\r\n\r\ntemplate<\/span><>                                        \/\/ (2)<\/span><\/span>                                 <\/span>\r\nstruct<\/span> product<><\/span> {\r\n  static<\/span> constexpr int<\/span> value =<\/span> 1<\/span>;\r\n};\r\n\r\ntemplate<\/span><<\/span>int<\/span> i, int<\/span>... tail>                      \/\/ (3)<\/span><\/span><\/span>\r\nstruct<\/span> product<<\/span>i, tail...><\/span> {\r\n  static<\/span> constexpr int<\/span> value =<\/span> i *<\/span> product<<\/span>tail...>::<\/span>value;\r\n};\r\n\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    std::<\/span>cout <<<\/span> \"sum<1, 2, 3, 4, 5>::value: \"<\/span> <<<\/span> sum<<\/span>1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>>::<\/span>value <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"product<1, 2, 3, 4, 5>::value: \"<\/span> <<<\/span> product<<\/span>1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>>::<\/span>value <<<\/span> std::<\/span>endl;\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The program calculates the sum and the product of the numbers 1 to 5 at compile time. In the case of the function template product<\/code>, line (1) declares the primary template, line (2) the full specialization for zero arguments, and line (3) the partial specialization for at least one argument. The definition of the primary template (1) is unnecessary if you don’t use it. The partial specialization (3) starts a recursive instantiation, which ends when all template arguments are consumed. In this case, the full specialization for zero arguments kicks in as the boundary condition. To know how this pack expansion is performed, study the example compileTimeVariadicTemplates.cpp<\/span> at C++ Insights<\/a>. <\/span><\/span><\/p>\n
\"compileTimeVariadicTemplate\"<\/p>\n
Thanks to fold expression, calculating at compile-time becomes way more manageable.<\/p>\n<\/p>\n
Fold Expressions in C++17<\/h2>\n
With C++17, we can directly reduce a parameter pack with a binary operator.<\/p>\n
 <\/p>\n
\n
\/\/ compiletimeFoldExpressions.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span>... Args><\/span>\r\nauto<\/span> sum(const<\/span> Args&<\/span>... args)\r\n{\r\n  return<\/span> (args +<\/span> ...);\r\n}\r\n\r\ntemplate<\/span><<\/span>typename<\/span>... Args><\/span>\r\nauto<\/span> product(const<\/span> Args&<\/span>... args)\r\n{\r\n  return<\/span> (args *<\/span> ...);\r\n}\r\n\r\nint<\/span> main() {\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    std::<\/span>cout <<<\/span> \"sum(1, 2, 3, 4, 5): \"<\/span> <<<\/span> sum(1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>) <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"product(1, 2, 3, 4, 5): \"<\/span> <<<\/span> product(1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>) <<<\/span> std::<\/span>endl;\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The program compiletimeFoldExpressions.cpp<\/code> produces the same result at compile-time, such as the previous program compileTimeVariadicTemplates.cpp<\/span>.<\/p>\n
\"compiletimeFoldExpressions\"<\/p>\n
Of course, there is more to write about fold expression. Please read the details in my previous post to Fold Expressions<\/a>.<\/p>\n
Now I want to dive into C++20.<\/p>\n
constexpr Containers and Algorithms in C++20<\/h2>\n
C++20 supports the constexpr<\/code> containers std::vector<\/code> and std::string. constexpr<\/code> means, in this case, that the member functions of both containers can be applied at compile-time.<\/p>\n
Before I write about both containers<\/code><\/code>, I have to make a short detour to C++17. The reason is simple: No compiler so far supports the constexpr<\/code> std::vector<\/code> and std::string<\/code>. In contrast, the GCC and the Microsoft Compiler support the constexpr<\/code> algorithms of the STL.<\/p>\n
In my following example, I use instead of a constexpr std::vector<\/code> a constexpr std::array. <\/code>Since C++17 std::array<\/code> can be declared as constexpr: constexpr std::array myArray{1, 2, 3}. <\/code><\/p>\n
Now starts the fun part. With C++20, you can use a std::array<\/code> at compile-time.<\/p>\n
\n
\/\/ constexprArray.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <numeric><\/span>\r\n#include <array><\/span>\r\n\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    constexpr std::<\/span>array myArray{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};                                     \/\/ (1)<\/span>\r\n    constexpr auto<\/span> sum =<\/span> std::<\/span>accumulate(myArray.begin(), myArray.end(), 0<\/span>);         \/\/ (2)<\/span>\r\n    std::<\/span>cout <<<\/span> \"sum: \"<\/span>  <<<\/span> sum <<<\/span> std::<\/span>endl;\r\n\r\n    constexpr auto<\/span> product =<\/span> std::<\/span>accumulate(myArray.begin(), myArray.end(), 1<\/span>,      \/\/ (3)<\/span>
                                             std::<\/span>multiplies<<\/span>int<\/span>><\/span>());\r\n    std::<\/span>cout <<<\/span> \"product: \"<\/span>  <<<\/span> product <<<\/span> std::<\/span>endl;\r\n\r\n    constexpr auto<\/span> product2 =<\/span> std::<\/span>accumulate(myArray.begin(), myArray.end(), 1<\/span>,     \/\/ (4)<\/span>
                                              [](auto<\/span> a, auto<\/span> b) { return<\/span> a *<\/span> b;});\r\n    std::<\/span>cout <<<\/span> \"product2: \"<\/span>  <<<\/span> product2 <<<\/span> std::<\/span>endl;\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The std::array<\/code> (1) and all results of the calculations are declared as constexpr<\/code>. Line (2) calculates the sum of all elements, and lines (3) and (4) calculate the product of all elements of myArray<\/code>. Line 2 is valid because myArray<\/code> is a constexpr<\/code> container and the algorithm std::accumulate<\/code> is declared as constexpr<\/code>. Lines (3) and (4) are more interesting. The call operator  std::multiplies<\/code><\/a> is constexpr<\/code> and since C++17 lambda expression can be constexpr<\/code>.<\/p>\n
Here is the output of the program:<\/p>\n
\"constexprArray\"<\/p>\n
Thanks to the Compiler Explorer<\/a>, I can present the results way more impressive. Here are the relevant assembler instructions of GCC.<\/p>\n
\"constexprArrayCompilerExplorer\"<\/p>\n
 <\/p>\n
Lines 19, 29, and 39 show that the results of the array calculations become values in the assembler instructions.  This means std::accumulate<\/code> is performed at compile-time, and the calculation result is just available at run-time.<\/p>\n
As I already mentioned, no compiler so far supports a constexpr std::vector<\/code> or a constexpr std::string<\/code>. Consequently, I must cheat and assume that my compiler fully supports both constexpr<\/code> containers.<\/p>\n
 <\/p>\n
\n
\/\/ constexprVectorString.cpp<\/span>\r\n\r\n#include <algorithm><\/span>\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <vector><\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    constexpr std::<\/span>vector myVec {15<\/span>, -<\/span>5<\/span>, 0<\/span>, 5<\/span>, 10<\/span>};\r\n    constexpr std::<\/span>sort(myVec.begin(), myVec.end());\r\n    for<\/span> (auto<\/span> v:<\/span> myVec) std::<\/span>cout <<<\/span> v <<<\/span> \" \"<\/span>;\r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n\r\n    using<\/span> namespace<\/span> std::<\/span>string_literals;\r\n    constexpr std::<\/span>vector<<\/span>std::<\/span>string><\/span> myStringVec{\"Stroustrup\"<\/span>s, \"Vandevoorde\"<\/span>s, 
                                                   \"Sutter\"<\/span>s, \"Josuttis\"<\/span>s, \"Wong\"<\/span>s };\r\n    constexpr std::<\/span>sort(myStringVec.begin(), myStringVec.end());\r\n    for<\/span> (auto<\/span> s:<\/span> myStringVec) std::<\/span>cout <<<\/span> s <<<\/span> \" \"<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
With C++20, you can sort a std::vector<\/code> or a std::string<\/code> at compile-time.<\/p>\n
\"constexprVectorString\"<\/p>\n
What’s next?<\/h2>\n
C++20 adds many convenience functions to make working with containers of the Standard Template Library easier. For example, due to the functions std::erase<\/span> and std::erase_if<\/span>, the deletion of container elements works like a charm. When you want to know if a specific element is in an associative container, the member function contains<\/code> is quite handy.<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
Probably the most viral keyword in modern C++ is constexpr. With C++20, we have a constexpr std::vector and a constexpr std::string. Additionally, both containers can be manipulated with the constexpr algorithms of the Standard Template Library. <\/p>\n","protected":false},"author":21,"featured_media":5945,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[428,455],"class_list":["post-5989","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20","tag-constexpr","tag-vector"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5989","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=5989"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5989\/revisions"}],"predecessor-version":[{"id":6728,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5989\/revisions\/6728"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5945"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5989"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5989"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5989"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}