{"id":5830,"date":"2019-12-20T07:31:58","date_gmt":"2019-12-20T07:31:58","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-20-concepts-what-we-dont-get\/"},"modified":"2023-06-26T09:56:32","modified_gmt":"2023-06-26T09:56:32","slug":"c-20-concepts-what-we-dont-get","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-20-concepts-what-we-dont-get\/","title":{"rendered":"C++20: Concepts – What we don’t get"},"content":{"rendered":"

The Template Introduction from the Concepts TS is a new way to use concepts. This syntactic variant is not included in the Concepts Draft and, therefore, in the C++20 standard. But I don’t know what the farther-away future brings.<\/p>\n

<\/p>\n

 <\/p>\n

 \"TimelineCpp20Concepts\"<\/h3>\n

Template Introduction<\/h3>\n

Let me first start with a short riddle. Which of the following syntactic variants is not possible with the draft of the concept?<\/p>\n

 <\/p>\n

\n
template<\/span><<\/span>typename<\/span> T><\/span>                                  \/\/ (1)<\/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\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>                                  \/\/ (2)<\/span>\r\nT gcd1(T a, T b) requires Integral<<\/span>T><\/span>{\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\r\ntemplate<\/span><<\/span>Integral T><\/span>                                  \/\/ (3)<\/span>\r\nT gcd2(T a, T 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\r\nIntegral auto<\/span> gcd3(Integral auto<\/span> a, Integral auto<\/span> b){ \/\/ (4)<\/span>\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\r\nIntegral{T}                                           \/\/ (5)<\/span>\r\nIntegral gcd(T a, T b){\r\n  if<\/span>( b ==<\/span> 0<\/span> ){ return<\/span> a; }\r\n  else<\/span>{\r\n    return<\/span> gcd(b, a %<\/span> b);\r\n  }\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Maybe, you don’t know. So let me name the five variants.<\/p>\n
    \n
  1. Requires clause<\/li>\n
  2. Trailing requires clause<\/li>\n
  3. Constrained template parameters<\/li>\n
  4. Abbreviated Function Templates<\/li>\n
  5. Template Introduction<\/li>\n<\/ol>\n
    I assume you have chosen the most obscure one: Template Introduction. You are right. Maybe we get it with a later C++ standard, but I’m highly skeptical. In my talks in the last year, I heard no one complaining that they are not part of C++20. I’m also not a big fan of Template Introduction because they introduced a new asymmetry; you know, I’m not a fan of asymmetries.<\/p>\n<\/p>\n
    The Asymmetry<\/h3>\n
    Instead of declaring your constrained template using template<Integral T><\/span>, you can see Integral{T}<\/span>. Here, you see the asymmetry. You can only use Template Introduction with concepts (constrained placeholders) but not with auto<\/span> (unconstrained placeholders). The following example makes my point. This and the following example is based on the previous concepts’ TS specification and compiled with the GCC.<\/p>\n
     <\/p>\n
    \n
    \/\/ templateIntroduction.cpp<\/span>\r\n\r\n#include <type_traits><\/span>\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/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\r\nIntegral{T}                            \/\/ (1)<\/span>\r\nIntegral gcd(T a, T b){\r\n  if<\/span>( b ==<\/span> 0<\/span> ){ return<\/span> a; }\r\n  else<\/span>{\r\n    return<\/span> gcd(b, a %<\/span> b);\r\n  }\r\n}\r\n\r\nIntegral{T}                            \/\/ (2)<\/span>\r\nclass<\/span> ConstrainedClass<\/span>{};\r\n\r\n\/*<\/span>\r\n\r\nauto{T}                                \/\/ (4)<\/span>\r\nauto gcd(T a, T b){<\/span>\r\n  if( b == 0 ){ return a; }<\/span>\r\n  else{<\/span>\r\n    return gcd(b, a % b);<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n\r\nauto{T}                                \/\/ (5)<\/span>\r\nclass ConstrainedClass{};<\/span>\r\n\r\n*\/<\/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  auto<\/span> res=<\/span> gcd(100<\/span>, 10<\/span>); \r\n\r\n  ConstrainedClass<<\/span>int<\/span>><\/span> constrainedClass;\r\n  ConstrainedClass<<\/span>double<\/span>><\/span> constrainedClass1;  \/\/ (3)<\/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 use Template introduction for the function template gcd<\/span> (line 1) and the class template ConstrainedClass<\/span> (line 2). As expected,  the concept will kick in if I try to instantiate ConstraintedClass<\/span> for double<\/span> (line 3).<\/p>\n
    \"templateIntroductionError\"<\/p>\n
     <\/p>\n
    I don’t like it that I can not just replace Integral<\/span> with auto<\/span>, such as in lines 4 and 5. Up to this point, I used constrained placeholders (concepts) and unconstrained placeholders (auto) interchangeably in my posts to concepts. This straightforward principle is gone with Template Introduction.<\/p>\n
    Of course, I could easily overcome this restriction by defining a concept that is always evaluated to true<\/span>.<\/p>\n
    \n
    \/\/ templateIntroductionGeneric.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <typeinfo><\/span>\r\n#include <utility><\/span>\r\n\r\nstruct<\/span> NoDefaultConstructor{               \/\/ (5)<\/span>\r\n    NoDefaultConstructor() =<\/span> delete<\/span>;\r\n};\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>                       \/\/ (1)<\/span>\r\nconcept bool<\/span> Generic(){\r\n  return<\/span> true<\/span>;\r\n}\r\n\r\nGeneric{T}                                 \/\/ (2)<\/span>\r\nGeneric gcd(T a, T b){\r\n  if<\/span>( b ==<\/span> 0<\/span> ){ return<\/span> a; }\r\n  else<\/span>{\r\n    return<\/span> gcd(b, a %<\/span> b);\r\n  }\r\n}\r\n\r\nGeneric{T}                                 \/\/ (3)<\/span>\r\nclass<\/span> ConstrainedClass<\/span>{\r\npublic:<\/span>\r\n  ConstrainedClass(){\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(decltype(std::<\/span>declval<<\/span>T><\/span>())).name()   \/\/ (4)<\/span>\r\n              <<<\/span> std::<\/span>endl;\r\n  }\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> \"gcd(100, 10): \"<\/span> <<<\/span> gcd(100<\/span>, 10<\/span>) <<<\/span> std::<\/span>endl;\r\n  \r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n  ConstrainedClass<<\/span>int<\/span>><\/span> genericClassInt;\r\n  ConstrainedClass<<\/span>std::<\/span>string><\/span> genericClassString;\r\n  ConstrainedClass<<\/span>double<\/span>><\/span> genericClassDouble;\r\n  ConstrainedClass<<\/span>NoDefaultConstructor><\/span> genericNoDefaultConstructor;\r\n  \r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    Generic<\/span> (line 1) is a concept that returns true<\/span> for all types. Now, I can unify the syntax and define an unconstrained function template (line 4) and an unconstrained class template (line 3). The terms unconstrained or constrained function templates or class templates are not official. I coined them for simplicity reasons.<\/p>\n
    The expression typeid(decltype(std::declval<T>())).name()<\/span> (line 4)  may look weird to you. std::declvar<T> <\/span>(C++11) converts the type parameter T into a reference type. Thanks to the reference type, you can use it in a decltype<\/span> expression to invoke any member function on T<\/span> without constructing T<\/span>. <\/span>It works even for a type T without a default constructor (line 5). In my case (line 4), I invoked the constructor on the reference type to get the string representation of the type parameter T. Here is the program’s output with GCC.<\/p>\n
    \"templateIntroductionGeneric2\"<\/p>\n
    What’s next?<\/h3>\n
    One big topic is left to complete the story concepts: define your concept. Most of the time, you reinvent the wheel because C++20 has many pre-defined concepts. Anyway, I will present in my next post <\/a>the pre-defined concepts and how you can define your own.<\/p>\n
     <\/p>\n<\/p>\n
     <\/p>\n
     <\/p>\n","protected":false},"excerpt":{"rendered":"
    The Template Introduction from the Concepts TS is a new way to use concepts. This syntactic variant is not included in the Concepts Draft and, therefore, in the C++20 standard. But I don’t know what the farther-away future brings.<\/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],"class_list":["post-5830","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20","tag-concepts"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5830","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=5830"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5830\/revisions"}],"predecessor-version":[{"id":6761,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5830\/revisions\/6761"}],"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=5830"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5830"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5830"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}