{"id":6353,"date":"2022-04-27T14:11:38","date_gmt":"2022-04-27T14:11:38","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/using-requires-expression-in-c-20-as-a-standalone-feature\/"},"modified":"2023-06-26T09:07:20","modified_gmt":"2023-06-26T09:07:20","slug":"using-requires-expression-in-c-20-as-a-standalone-feature","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/using-requires-expression-in-c-20-as-a-standalone-feature\/","title":{"rendered":"Using Requires Expression in C++20 as a Standalone Feature"},"content":{"rendered":"

In my last post “Defining Concepts with Requires Expressions<\/a>“, I exemplified how you can use requires expressions to define concepts. Requires expressions can also be used as a standalone feature when a compile-time predicate is required.<\/p>\n

<\/p>\n

 \"TimelineCpp20Concepts\"<\/p>\n

Typical use cases for compile-time predicates are static_assert<\/code>, constexpr if<\/code>, or a requires clause. A compile–time predicate is an expression that returns at compile time a boolean. Let me start this post with C++11.<\/p>\n

static_assert<\/code><\/h2>\n
\n
static_assert<\/code> requires a compile-time predicate, and a message is displayed when the compile-time predicate fails. With C++17, the message is optional. With C++20, this compile-time predicates can be a requires expression.<\/div>\n
 <\/div>\n

<\/p>\n

\n
\/\/ staticAssertRequires.cpp<\/span>\r\n\r\n#include <concepts><\/span>\r\n#include <iostream><\/span>\r\n\r\nstruct<\/span> Fir {                   \/\/ (4)<\/span>\r\n    int<\/span> count() const<\/span> {\r\n        return<\/span> 2020<\/span>;\r\n    }\r\n};\r\n\r\nstruct<\/span> Sec {\r\n    int<\/span> size() const<\/span> {\r\n        return<\/span> 2021<\/span>;\r\n    }\r\n};\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n   \r\n    Fir fir;\r\n    static_assert(requires(Fir fir){ { fir.count() } -><\/span> std::<\/span>convertible_to<<\/span>int<\/span>><\/span>; });     \/\/ (1)<\/span>\r\n\r\n    Sec sec;\r\n    static_assert(requires(Sec sec){ { sec.count() } -><\/span> std::<\/span>convertible_to<<\/span>int<\/span>><\/span>; });     \/\/ (2)<\/span>\r\n\r\n    int<\/span> third;\r\n    static_assert(requires(int<\/span> third){ { third.count() } -><\/span> std::<\/span>convertible_to<<\/span>int<\/span>><\/span>; }); \/\/ (3)<\/span>\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n<\/div>\n
 <\/div>\n
\n
\n
The requires expressions (lines 1, 2, and 3) check if the object has a member function count<\/code> and if its result is convertible to int<\/code>. This check is only valid for the class First<\/code> (lines 4). On the contrary, the checks in lines (2) and (3) fail.<\/div>\n
\"staticAssertRequires\"<\/div>\n
 <\/div>\n<\/div>\n<\/div>\n
\n
Maybe, you want to compile code depending on a compile-time check. In this case, the C++17 feature constexpr if<\/code> combined with requires expressions provides you with the necessary tool.<\/div>\n
 <\/div>\n
<\/div>\n
constexpr if<\/code><\/h2>\n
\n
constexpr if<\/code> allows it to compile source code conditionally. For the condition, the requires expression comes into play. All branches of the if statement have to be valid.<\/div>\n
<\/p>\n
Thanks to constexpr if<\/code>, you can define functions that inspect their arguments at compile time and generate different functionality based on their analysis.<\/div>\n
 <\/div>\n
 <\/div>\n<\/div>\n<\/div>\n
<\/p>\n
\n
\/\/ constexprIfRequires.cpp<\/span>\r\n\r\n#include <concepts><\/span>\r\n#include <iostream><\/span>\r\n\r\nstruct<\/span> First {\r\n    int<\/span> count() const<\/span> {\r\n        return<\/span> 2020<\/span>;\r\n    }\r\n};\r\n\r\nstruct<\/span> Second {\r\n    int<\/span> size() const<\/span> {\r\n        return<\/span> 2021<\/span>;\r\n    }\r\n};\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nint<\/span> getNumberOfElements(T t) {\r\n\r\n    if<\/span> constexpr (requires(T t){ { t.count() } -><\/span> std::<\/span>convertible_to<<\/span>int<\/span>><\/span>; }) {   \/\/ (1)<\/em><\/span>\r\n        return<\/span> t.count();\r\n    }\r\n    if<\/span> constexpr (requires(T t){ { t.size() } -><\/span> std::<\/span>convertible_to<<\/span>int<\/span>><\/span>; }) {    \/\/ (2)<\/em><\/span>\r\n        return<\/span> t.size();\r\n    }\r\n    else<\/span> return<\/span> 42<\/span>;                                                                \/\/ (3)<\/em><\/span>\r\n\r\n}\r\n\r\nint<\/span> main() {\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n   \r\n    First first;\r\n    std::<\/span>cout <<<\/span> \"getNumberOfElements(first): \"<\/span>  <<<\/span> getNumberOfElements(first) <<<\/span> '\\n'<\/span>;\r\n\r\n    Second second;\r\n    std::<\/span>cout <<<\/span> \"getNumberOfElements(second): \"<\/span>  <<<\/span> getNumberOfElements(second) <<<\/span> '\\n'<\/span>;\r\n\r\n    int<\/span> third;\r\n    std::<\/span>cout <<<\/span> \"getNumberOfElements(third): \"<\/span> <<<\/span> getNumberOfElements(third) <<<\/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
\n
Lines (1) and (2) are crucial in this code example. In line (1), the requires expressions determine if the variable t<\/code> has a member function count<\/code> that returns an int<\/code>. Accordingly, line (2) determines if the variable t<\/code> has a member function size<\/code>. The else statement in line (3) is applied as a fallback.<\/div>\n
 <\/div>\n
\"constexprIfRequires\"<\/div>\n
Requires Clause<\/h2>\n
First of all, I have to answer the question: What is a requires clause?<\/p>\n
There are essentially four ways to use a concept, such as std::integral<\/code>.<\/p>\n<\/div>\n
<\/p>\n
\n
\/\/ conceptsIntegralVariations.cpp<\/span>\r\n\r\n#include <concepts><\/span>\r\n#include <type_traits><\/span>\r\n#include <iostream>      <\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>                          \/\/ (1)                          <\/span>\r\nrequires std::<\/span>integral<<\/span>T><\/span>                     \r\nauto gcd(T a, T b) {\r\n    if<\/span>( b ==<\/span> 0<\/span> ) return<\/span> a;\r\n    else<\/span> return<\/span> gcd<\/span>(b, a %<\/span> b);\r\n}\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>                          \/\/ (2)        <\/span>\r\nauto gcd1(T a, T b) requires std::<\/span>integral<<\/span>T><\/span> {  \r\n    if<\/span>( b ==<\/span> 0<\/span> ) return<\/span> a; \r\n    else<\/span> return<\/span> gcd1<\/span>(b, a %<\/span> b);\r\n}\r\n\r\ntemplate<\/span><<\/span>std::<\/span>integral T><\/span>                     \/\/ (3)        <\/span>\r\nauto gcd2(T a, T b) {\r\n    if<\/span>( b ==<\/span> 0<\/span> ) return<\/span> a; \r\n    else<\/span> return<\/span> gcd2<\/span>(b, a %<\/span> b);\r\n}\r\n                                           \r\nauto<\/span> gcd3(std::<\/span>integral auto<\/span> a, \/\/ (4)<\/span>\r\n          std::<\/span>integral auto<\/span> b) { \r\n    if<\/span>( b ==<\/span> 0<\/span> ) return<\/span> a; \r\n    else<\/span> return<\/span> gcd3<\/span>(b, a %<\/span> b);\r\n}\r\n\r\nint<\/span> main(){\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> \"gcd(100, 10)= \"<\/span>  <<<\/span>  gcd(100<\/span>, 10<\/span>)  <<<\/span> '\\n'<\/span>;\r\n    std::<\/span>cout <<<\/span> \"gcd1(100, 10)= \"<\/span> <<<\/span>  gcd1(100<\/span>, 10<\/span>)  <<<\/span> '\\n'<\/span>;\r\n    std::<\/span>cout <<<\/span> \"gcd2(100, 10)= \"<\/span> <<<\/span>  gcd2(100<\/span>, 10<\/span>)  <<<\/span> '\\n'<\/span>;\r\n    std::<\/span>cout <<<\/span> \"gcd3(100, 10)= \"<\/span> <<<\/span>  gcd3(100<\/span>, 10<\/span>)  <<<\/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
\n
Thanks to the header <concepts<\/code>> I can use the concept std::integral<\/code>. The concept is fulfilled if T<\/code> it is integral<\/a>. The function name gcd<\/code> stands for the greatest-common-divisor algorithm based on the Euclidean<\/a> algorithm.<\/div>\n
<\/p>\n
Here are the four ways to use concepts:<\/div>\n<\/div>\n
    \n
  1.  Requires clause (line 1)<\/li>\n
  2. Trailing requires clause (line 2)<\/li>\n
  3. Constrained template parameter (line 3)<\/li>\n
  4. Abbreviated function template (line 4)<\/li>\n<\/ol>\n
    \n
    For simplicity reasons, each function template returns auto<\/code>. There is a semantic difference between the function templates gcd, gcd1, gcd2<\/code>, and the function gcd3<\/code>. In the case of gcd, gcd1, or gcd2<\/code>, arguments a<\/code> and b<\/code> must have the same type. This does not hold for the function gcd3<\/code>. Parameters a<\/code> and b<\/code> can have different types but must both fulfill the concept std::integral.<\/code><\/div>\n
     <\/div>\n
    \"conceptsIntegralVariations\"<\/div>\n<\/div>\n
     <\/p>\n
    \n
    The functions gcd<\/code> and gcd1<\/code> use requires clauses.<\/div>\n
     <\/div>\n
    There is an interesting fact about requires clauses. You can use any compile-time predicate as an expression. I check in the following requirces clause if an int as a non-type template parameter is smaller than 20.<\/div>\n
     <\/div>\n
    <\/p>\n
    \n
    \/\/ requiresClause.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span> <<\/span>unsigned<\/span> int<\/span> i><\/span>\r\nrequires (i <=<\/span> 20<\/span>)             \/\/ (1)<\/span><\/em>\r\nint<\/span> sum(int<\/span> j) {\r\n    return<\/span> i +<\/span> j;\r\n}\r\n\r\nint<\/span> main() {\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> \"sum<20>(2000): \"<\/span> <<<\/span> sum<<\/span>20<\/span>><\/span>(2000<\/span>) <<<\/span> '\\n'<\/span>,\r\n    \/\/ std::cout << \"sum<23>(2000): \" << sum<23>(2000) << '\\n',  \/\/ ERROR <\/span>\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
     <\/div>\n
    \n
    \n
    The compile-time predicate used in line (1) exemplifies an interesting point: the requirement is applied to the non-type i<\/code>, and not on a type as usual.<\/div>\n
     <\/div>\n
    \"requiresClause\"<\/div>\n
     <\/div>\n
    \n
    When you use the commented-out line in the main<\/code> program, the clang compiler reports the following error:<\/div>\n
     <\/div>\n
    \"requiresClauseError\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n
     <\/div>\n
    Here are more details about non-type template parameters: “Alias Templates and Template Parameters<\/a>“.<\/div>\n
     <\/div>\n
    Typically, you use a concept in a requires clause, but there is more: requires requires<\/code> or anonymous concepts<\/div>\n
    requires requires<\/code> or anonymous concepts<\/h3>\n
     <\/div>\n
    \n
    \n
    You can define an anonymous concept and directly use it. In general, you should not do it. Anonymous concepts make your code hard to read, and you cannot reuse your concepts.<\/div>\n
     <\/div>\n<\/div>\n<\/div>\n
    <\/p>\n
    \n
    template<\/span><<\/span>typename<\/span> T><\/span>\r\n    requires requires (T x) { x + x; } <\/span>\r\nauto add(T a, T b) { 
        return<\/span> a +<\/span> b; 
    }\r\n<\/pre>\n<\/div>\n<\/div>\n
     <\/p>\n
    \n
    The function template defines its concept as ad-hoc. The function template add <\/code>uses a requires expression (requires(T x) { x + x; }<\/code><\/span> ) inside a requires clause. The anonymous concept is equivalent to the following concept Addable.<\/div>\n
     <\/div>\n
    <\/p>\n
    \n
    template<\/span><<\/span>typename<\/span> T><\/span>\r\nconcept Addable =<\/span> requires (T a, T b) {\r\n    a +<\/span> b; \r\n};\r\n<\/pre>\n<\/div>\n
     <\/div>\n
    Consequentially, the following four implementations of the function template add<\/code> are equivalent to the previous one:<\/div>\n
     <\/div>\n
     <\/div>\n<\/div>\n
    <\/p>\n
    \n
    template<\/span><<\/span>typename<\/span> T><\/span>  \/\/ requires clause<\/span>\r\n    requires Addable<<\/span>T><\/span>\r\nauto<\/span> add(T a, T b) { \r\n    return<\/span> a +<\/span> b; \r\n}\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>  \/\/ trailing requires clause<\/span>\r\nauto<\/span> add(T a, T b) requires Addable<<\/span>T><\/span> { \r\n    return<\/span> a +<\/span> b; \r\n} \r\n\r\ntemplate<\/span><<\/span>Addable T><\/span>   \/\/ constrained template parameter<\/span>\r\nauto<\/span> add(T a, T b){ \r\n    return<\/span> a +<\/span> b; \r\n} \r\n                     \/\/ abbreviated function template<\/span>\r\nauto<\/span> add(Addable auto<\/span> a, Addable auto<\/span> b) {\r\n    return<\/span> a +<\/span> b;\r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    As a short reminder: The last implementation based on abbreviated function templates syntax can deal with values having different types.<\/p>\n
    Again, I want to emphasize it: Concepts should encapsulate general ideas and give them a self-explanatory name for reuse. They are invaluable for maintaining code. Anonymous concepts read more like syntactic constraints on template parameters and should be avoided.<\/strong><\/p>\n
    What’s next?<\/h2>\n
    \n
    Using a concept in static_assert(Concept<T><\/code>) tests whether the type T<\/code> fulfills the concept. Let’s see how we can use this in my next post.<\/div>\n
     <\/div>\n
    <\/div>\n<\/div>\n
     <\/p>\n
     <\/p>\n","protected":false},"excerpt":{"rendered":"
    In my last post “Defining Concepts with Requires Expressions“, I exemplified how you can use requires expressions to define concepts. Requires expressions can also be used as a standalone feature when a compile-time predicate is required.<\/p>\n","protected":false},"author":21,"featured_media":5808,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[415,418],"class_list":["post-6353","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20","tag-concepts","tag-requires-expressions"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6353","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=6353"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6353\/revisions"}],"predecessor-version":[{"id":6671,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6353\/revisions\/6671"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5808"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6353"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6353"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6353"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}