{"id":5834,"date":"2020-01-17T07:23:26","date_gmt":"2020-01-17T07:23:26","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-20-concepts-defining-concepts\/"},"modified":"2023-06-26T09:56:07","modified_gmt":"2023-06-26T09:56:07","slug":"c-20-concepts-defining-concepts","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-20-concepts-defining-concepts\/","title":{"rendered":"C++20: Define Concepts"},"content":{"rendered":"

With this post, I start my last fascinating topic to concepts: define your concepts. Consequentially, I answer the questions I opened in previous posts.<\/p>\n

<\/p>\n

 <\/p>\n

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

First and foremost, most of the concepts I define are already available in the C++ 20 draft. Therefore, there is no need to define them. To distinguish my concepts from the predefined concepts, I capitalize them. My previous post gave an overview of the predefined concepts: C++20: Concepts – Predefined Concepts<\/a>.<\/p>\n

Defining concepts<\/h2>\n

There are two typical ways to define concepts: direct definition or requires-expressions. <\/p>\n

Direct definition<\/h3>\n

The syntactic form changed a little bit from the syntax based on the concepts TS (Technical Specification) to the proposed syntax for the C++20 standard. <\/p>\n

Concepts TS<\/h4>\n
\n
template<\/span><<\/span>typename<\/span> T><\/span>\r\nconcept bool<\/span> Integral(){\r\n    return<\/span> std::<\/span>is_integral<<\/span>T>::<\/span>value;\r\n}\r\n<\/pre>\n<\/div>\n
C++20 standard <\/h4>\n
\n
template<\/span><<\/span>typename<\/span> T><\/span>\r\nconcept Integral =<\/span> std::<\/span>is_integral<<\/span>T>::<\/span>value;\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The C++20 standard syntax is less verbose. Both used under the hood the function std::is_integral<T>::value<\/span> from the C++11 type-traits library<\/a>. T<\/span> fulfills the concept if the compile-time predicate std::integral<T>::value<\/span> evaluates to true<\/span>. Compile-time predicate means that the function runs at compile-time and returns a boolean. Since C++17, you can write std::integral<T>::value<\/span> less verbose: std::integral_v<T>. <\/span><\/p>\n
I’m unsure if the two terms variable concept<\/strong> for direct definition and function concept<\/strong> for requires-expressions are still used. Still, they help to keep the difference between the direct definition and the requires-expressions in mind. <\/p>\n
 <\/p>\n
I skip the example to the usage of the concept Integral<\/span>. If you are curious, read my previous post: C++ 20: Concepts, the Placeholder Syntax<\/a>. <\/p>\n<\/p>\n
Requires-expressions<\/h3>\n
Analogous to the direct definition, the syntax of requires-expressions also changed from the concepts TS to the proposed draft C++20 standard. <\/p>\n
Concepts TS <\/h4>\n
<\/p>\n
\n
template<\/span><<\/span>typename<\/span> T><\/span>\r\nconcept bool<\/span> Equal(){\r\n    return<\/span> requires(T a, T b) {\r\n        { a ==<\/span> b } -><\/span> bool<\/span>;\r\n        { a !=<\/span> b } -><\/span> bool<\/span>;\r\n   };\r\n}\r\n<\/pre>\n<\/div>\n
C++20 standard<\/h4>\n
<\/p>\n
\n
template<\/span><<\/span>typename<\/span> T><\/span>\r\nconcept Equal =<\/span>\r\n    requires(T a, T b) {\r\n        { a ==<\/span> b } -><\/span> bool<\/span>;\r\n        { a !=<\/span> b } -><\/span> bool<\/span>;\r\n    };\r\n<\/pre>\n<\/div>\n
 <\/p>\n
As before, the C++20 syntax is more concise. T<\/span> fulfills the concept if the operator ==<\/span> and !=<\/span> are overloaded and return a boolean. Additionally, the types of a<\/span> and b<\/span> have to be the same.<\/p>\n
The concept Equal<\/h3>\n
Now, it’s time to use the concept Equal<\/span>: <\/p>\n
<\/p>\n
\n
\/\/ conceptsDefintionEqual.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nconcept Equal =<\/span>\r\n    requires(T a, T b) {\r\n        { a ==<\/span> b } -><\/span> bool<\/span>;\r\n        { a !=<\/span> b } -><\/span> bool<\/span>;\r\n};\r\n\r\n\r\nbool<\/span> areEqual<\/span>(Equal auto a, Equal auto b) {                     \/\/ (1)<\/span>            \r\n  return<\/span> a ==<\/span> b;\r\n}\r\n\r\n\/*<\/span>\r\n\r\nstruct WithoutEqual{<\/span>\r\n  bool operator==(const WithoutEqual& other) = delete;<\/span>\r\n};<\/span>\r\n\r\nstruct WithoutUnequal{<\/span>\r\n  bool operator!=(const WithoutUnequal& other) = delete;<\/span>\r\n};<\/span>\r\n\r\n*\/<\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n  \r\n  std::<\/span>cout <<<\/span> std::<\/span>boolalpha <<<\/span> std::<\/span>endl;\r\n  \r\n  std::<\/span>cout <<<\/span> \"areEqual(1, 5): \"<\/span> <<<\/span> areEqual(1<\/span>, 5<\/span>) <<<\/span> std::<\/span>endl;\r\n  \r\n  \/*<\/span>\r\n  <\/span>\r\n  bool res = areEqual(WithoutEqual(),  WithoutEqual());<\/span>\r\n  <\/span>\r\n  bool res2 = areEqual(WithoutUnequal(),  WithoutUnequal());<\/span>\r\n  <\/span>\r\n  *\/<\/span>\r\n  \r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n  \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I used the concept of <\/span>Equal<\/span> in the function <\/span>areEqual<\/span> (line 1). To remind you. Using a concept as a function parameter, the compiler creates a function template under the hood, with the concept specified constraints on the parameters. To get more information on this concise syntax, read my post: C++ 20: Concepts, the Placeholder Syntax<\/a>. <\/span><\/p>\n
 <\/p>\n
The output is not so exciting: <\/span>
<\/span><\/p>\n
\"conceptsDefinitionEqual\"<\/p>\n
Now, it has become exciting. What happens if I use the types WithoutEqual<\/span> and WithoutUnequal<\/span>. I intentionally set the == <\/span> operator and the !=<\/span> operator to delete<\/span>. The compiler complains immediately that both types do not fulfill the concept of Equal<\/span>. <\/p>\n
\"conceptsDefinitionEqualError\"<\/p>\n
When you look carefully at the error message, you see the reason: (a == b)<\/span> would be ill-formed, and (a != b)<\/span> would be ill-formed. <\/p>\n
Before I continue, I have to make a short detour. You can skip the detour if you don’t want to compile the program.<\/p>\n
The Implementation status of concepts<\/h4>\n
I faked the output of the program conceptsDefinitonEqual.cpp<\/span>. The output is from the Concepts TS implementation of GCC. Currently, no C++20 standard-conforming implementation of the concepts syntax is available.<\/p>\n