![\"TimelineCpp20Concepts\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/11\/TimelineCpp20Concepts.png\")
<\/p>\nThere are two ways to define a concept: You can combine existing concepts and compile-time predicates, or you can apply a requires expression in four different ways.<\/p>\n
<\/p>\n
<\/p>\n
Before I write about C++20 and Concepts, I want to remark briefly.<\/p>\n
I have written over 80 posts about C++20<\/a> and 20 about Concepts<\/a>. My previous C++20 posts are one to three years old. This has two important implications. First, I learned, in the meantime, a lot of new stuff about C++20. Second, you don’t have my previous posts in mind. Consequentially, I provide so much content in these posts in my second iteration through C++20 that you can follow my explanation and provide links to my previous posts if necessary.<\/p>\n Following this strategy, here is the general idea of concepts.<\/p>\n<\/p>\n Generic programming with templates enables it to define functions and classes which can be used with various types. As a result, it is not uncommon for you to instantiate a template with the wrong type. The result can be many pages of cryptic error messages. This problem ends with concepts. Concepts empower you to write requirements for template parameters checked by the compiler and revolutionize how we think about and write generic code. Here is why:<\/p>\n Additionally, this is not the end of the story.<\/p>\n The following code snippet demonstrates the definition and the use of the straightforward concept <\/p>\n The The <\/p>\n <\/p>\n The If you need more information about concepts, read the four following posts:<\/p>\n After this introduction, let me define concepts.<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\nConcepts<\/h2>\n
\n
\n
Integral<\/code>:<\/p>\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nconcept Integral =<\/span> std::<\/span>is_integral<<\/span>T>::<\/span>value;
\r\nIntegral auto<\/span> gcd<\/span>(Integral auto<\/span> a, Integral auto<\/span> b) {\r\n if<\/span>( b ==<\/span> 0<\/span> ) return<\/span> a;\r\n else<\/span> return<\/span> gcd(b, a %<\/span> b);\r\n}\r\n<\/pre>\n<\/div>\nIntegral<\/code> concept requires from its type parameter T<\/code> that std::is_integral<T>::value<\/code> evaluates to true. std::is_integral<T>::value<\/code> is a function from the type traits library<\/a> checking at compile time if T<\/code> is integral. If std::is_integral<T>::value<\/code> evaluates to true<\/code>, all is fine; otherwise, you get a compile-time error.<\/p>\ngcd<\/code> algorithm determines the greatest common divisor based on the Euclidean <\/a>algorithm. The code uses the so-called abbreviated function template syntax to define gcd<\/code>. Here, gcd requires that its arguments and return type support the concept Integral<\/code>. In other words, gcd<\/code> is a function template that puts requirements on its arguments and return value. When I remove the syntactic sugar, you can see the nature of gcd.
The semantically equivalent gcd<\/code> algorithm, using a requires<\/code> clause.<\/p>\n\ntemplate<\/span><<\/span>typename<\/span> T><\/span> \r\nrequires Integral<<\/span>T><\/span>\r\nT 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<\/pre>\n<\/div>\nrequires<\/code> clause states the requirements on the type parameters of gcd<\/code>.<\/p>\n\n
Define Concepts<\/h2>\n
\nWhen the concept you are looking for is not one of the predefined concepts in C++20, you must define your concept. I will define a few concepts distinguishable from the predefined concepts through CamelCase syntax. Consequently, my concept for a signed integral is named SignedIntegral<\/code>, whereas the C++ standard concept goes by the name signed_integra<\/code>l.<\/div>\n <\/div>\n\n\nThe syntax to define a concept is straightforward:<\/div>\n<\/div>\n<\/div>\n <\/div>\n<\/div>\n\ntemplate<\/span> <<\/span>template<\/span>-<\/span>parameter-<\/span>list><\/span>\r\nconcept concept-<\/span>name =<\/span> constraint-<\/span>expression;\r\n<\/pre>\n<\/div>\n\nA concept definition starts with the keyword template<\/code> and has a template parameter list. The second line is more interesting. It uses the keyword concept<\/code> followed by the concept name and the constraint expression.<\/div>\n <\/div>\n\n\nA constraint-expression<\/code> is a compile-time predicate. A compile-time predicate is a function that runs at compile time and returns a boolean. This compile-time predicate can either be:<\/div>\n\n
&&<\/code>), disjunctions (||<\/code>), or negations (!<\/code>)<\/li>\n<\/ul>\n\n
\n
Let me continue with the first variant:<\/div>\n <\/div>\nA Logical Combination of other Concepts or Compile-Time Predicates<\/h3>\n
\nYou can combine concepts and compile-time predicates using conjunctions (&&<\/code>) and disjunctions (||<\/code>). You can negate components using the exclamation mark (!<\/code>). Evaluation of this logical combination of concepts and compile-time predicates obeys short-circuit evaluation. Short circuit evaluation means that the evaluation of a logical expression automatically stops when its overall result is already determined.<\/div>\n\n<\/p>\nThanks to the many compile-time predicates of the type traits library<\/a>, you have all tools required to build powerful concepts at your disposal.<\/div>\n <\/div>\n\n\nLet’s start with the concepts Integral<\/code>, SignedIntegral<\/code>, and UnsignedIntegral<\/code>. <\/div>\n <\/div>\n<\/div>\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span> \/\/ (1)<\/span>\r\nconcept Integral =<\/span> std::<\/span>is_integral<<\/span>T>::<\/span>value;\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span> \/\/ (2)<\/span>\r\nconcept SignedIntegral =<\/span> Integral<<\/span>T><\/span> &&<\/span> std::<\/span>is_signed<<\/span>T>::<\/span>value;\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span> \/\/ (3)<\/span>\r\nconcept UnsignedIntegral =<\/span> Integral<<\/span>T><\/span> &&<\/span> !<\/span>SignedIntegral<<\/span>T><\/span>;\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n <\/div>\nI used the type-traits function std::is_integral to define the concept Integral<\/code> (line 1). Thanks to the function std::is_signed, I refine the concepts Integral<\/code> to the concept SignedIntegral<\/code> (line 2). Finally, negating the concept SignedIntegral<\/code> gives me the concept UnsignedIntegral<\/code> (line 3). Okay, let’s try it out.<\/div>\n <\/div>\n\n\/\/ SignedUnsignedIntegrals.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nconcept Integral =<\/span> std::<\/span>is_integral<<\/span>T>::<\/span>value;\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nconcept SignedIntegral =<\/span> Integral<<\/span>T><\/span> &&<\/span> std::<\/span>is_signed<<\/span>T>::<\/span>value;\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nconcept UnsignedIntegral =<\/span> Integral<<\/span>T><\/span> &&<\/span> !<\/span>SignedIntegral<<\/span>T><\/span>;\r\n\r\nvoid<\/span> func<\/span>(SignedIntegral auto<\/span> integ) { \/\/ (1)<\/span>\r\n std::<\/span>cout <<<\/span> \"SignedIntegral: \"<\/span> <<<\/span> integ <<<\/span> '\\n'<\/span>;\r\n}\r\n\r\nvoid<\/span> func<\/span>(UnsignedIntegral auto<\/span> integ) { \/\/ (2)<\/span>\r\n std::<\/span>cout <<<\/span> \"UnsignedIntegral: \"<\/span> <<<\/span> integ <<<\/span> '\\n'<\/span>;\r\n}\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n func(-<\/span>5<\/span>);\r\n func(5u<\/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<\/div>\n<\/div>\n<\/div>\n\nI use the abbreviated function-template syntax to overload the function func<\/code> on the concept SignedIntegral<\/code> (line 1) and UnsignedIntegral<\/code> (line 2). Read more about the abbreviated function template syntax in my previous post: C++20: Concepts – Syntactic Sugar<\/a>. The compiler chooses the expected overload:<\/div>\n <\/div>\n![\"signedUnsignedIntegrals\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/04\/signedUnsignedIntegrals.png\")
<\/div>\n <\/div>\n\n\nFor completeness reasons, the following concept Arithmetic<\/code> uses disjunction.<\/div>\n