{"id":5828,"date":"2019-12-13T08:59:13","date_gmt":"2019-12-13T08:59:13","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-20-concept-syntactic-sugar\/"},"modified":"2023-06-26T09:56:45","modified_gmt":"2023-06-26T09:56:45","slug":"c-20-concept-syntactic-sugar","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-20-concept-syntactic-sugar\/","title":{"rendered":"C++20: Concepts – Syntactic Sugar"},"content":{"rendered":"

Today, my post is not about something new to concepts. It’s about syntactic sugar. I write about abbreviated function templates. What? Abbreviated function templates allow a sweet way to define templates.<\/p>\n

<\/p>\n

 <\/p>\n

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

First of all, here is the definition of syntactic sugar from Wikipedia<\/a>:<\/p>\n

In computer science, syntactic sugar<\/em> is syntax<\/em> within a programming language that is designed to make things easier to read or express. It makes the language “sweeter” for human use: things can be expressed more clearly, concisely, or in an alternative style that some may prefer.<\/span><\/p>\n

The syntactic sugar I’m writing today is called abbreviated function templates.<\/p>\n<\/p>\n

Abbreviated Function Templates<\/h2>\n

I wrote in my last post about concepts C++20: Concepts, the Placeholder Syntax<\/a> that we have had since C++14, a significant asymmetry: generic lambdas introduced a new way to define function templates. Just use auto<\/span> as a function parameter. On the contrary, you can not use auto<\/span> as a function parameter to get a function template.<\/p>\n

\n
\/\/ genericLambdaFunction.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n\r\nauto<\/span> addLambda =<\/span> [](auto<\/span> fir, auto<\/span> sec){ return<\/span> fir +<\/span> sec; }; \/\/ (1)<\/span>\r\n\r\nauto<\/span> addFunction<\/span>(auto<\/span> fir, auto<\/span> sec){ return<\/span> fir +<\/span> sec; }     \/\/ (2)<\/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> addLambda(1<\/span>, 5<\/span>) <<<\/span> \" \"<\/span> <<<\/span> addFunction(1<\/span>, 5<\/span>) <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> addLambda(true<\/span>, 5<\/span>) <<<\/span> \" \"<\/span> <<<\/span> addFunction(true<\/span>, 5<\/span>) <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> addLambda(1<\/span>, 5.5<\/span>) <<<\/span> \" \"<\/span> <<<\/span> addFunction(1<\/span>, 5.5<\/span>) <<<\/span> std::<\/span>endl;\r\n    \r\n    const<\/span> std::<\/span>string fir{\"ge\"<\/span>};\r\n    const<\/span> std::<\/span>string sec{\"neric\"<\/span>};\r\n    std::<\/span>cout <<<\/span> addLambda(fir, sec) <<<\/span> \" \"<\/span> <<<\/span> addFunction(fir, sec) <<<\/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 Clang compiler speaks clear language when I try to compile this program with the C++14 standard.<\/p>\n
\"genericLambdaFunction\"<\/p>\n
How strange! I can use auto<\/span> as the return type and for the function parameters in a lambda (line 1), but I can only use auto<\/span> as the return type of a function (line 2).<\/p>\n
I’m happy to say. This weird behavior is gone with C++20, and the unification is extended to concepts.<\/p>\n
 <\/p>\n
\n
\/\/ conceptsIntegralVariationsDraft.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>                                  \/\/ (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\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>                                  \/\/ (3)<\/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>                                  \/\/ (4)<\/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){ \/\/ (5)<\/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\nauto<\/span> gcd4(auto<\/span> a, auto<\/span> b){                            \/\/ (6)<\/span>\r\n    if<\/span>( b ==<\/span> 0<\/span> ){ return<\/span> a; }\r\n    return<\/span> gcd(b, a %<\/span> b);\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> \"gcd(100, 10)= \"<\/span>  <<<\/span>  gcd(100<\/span>, 10<\/span>)  <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"gcd1(100, 10)= \"<\/span> <<<\/span>  gcd1(100<\/span>, 10<\/span>)  <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"gcd2(100, 10)= \"<\/span> <<<\/span>  gcd2(100<\/span>, 10<\/span>)  <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"gcd3(100, 10)= \"<\/span> <<<\/span>  gcd3(100<\/span>, 10<\/span>)  <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"gcd4(100, 10)= \"<\/span> <<<\/span>  gcd3(100<\/span>, 10<\/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
Let me describe in a few words the already known stuff for my previous posts to concepts. Line 1 defines the concept Integral<\/span>. gcd – gcd2<\/span> (lines 2 – 4) use the concept in various ways. gcd<\/span> used the required clause, gcd1 <\/span>the so-called trailing requires clause, and gcd2<\/span> constrained template parameters.<\/p>\n
With gcd3<\/span>, the syntactic sugar starts. The function declaration Integral auto gcd3(Integral auto a, Integral auto b)<\/span> requires from its type parameters that they support the concept Integral. <\/span>This syntactic form is the new way to use a concept and get a function template equivalent to the previous versions <\/span>gcd – gcd2.<\/p>\n
The syntactic form of gcd3 and gcd4 is called abbreviated function templates<\/strong>. Integral auto<\/span> in the declaration of gcd3<\/span> is a  constrained placeholder (concept), but you can also use an unconstrained placeholder (auto)<\/span>  in a function declaration such as in gcd4<\/span> (line 6). Before I make a few additional remarks to this new syntax, here is the output of the program:<\/p>\n
\"conceptsIntegralVariationsDraft\"<\/p>\n
An unconstrained placeholder (auto)<\/span> in a function declaration generates a function template. The following two functions add<\/span> are equivalent:<\/p>\n
\n
template<\/span><<\/span>typename<\/span> T, typename<\/span> T2><\/span>\r\nauto<\/span> add(T fir, T2 sec){\r\n    return<\/span> fir +<\/span> sec;\r\n}\r\n\r\nauto<\/span> add(auto<\/span> fir, auto<\/span> sec){\r\n    return<\/span> fir +<\/span> sec;\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The critical observation is that both arguments can have different types. The same holds for concepts.<\/p>\n
 <\/p>\n
\n
template<\/span><<\/span>Arithmetic T, Arithmetic T2>                           \/\/ (1)<\/span><\/span>\r\nauto<\/span> sub(T fir, T2 sec){\r\n    return<\/span> fir -<\/span> sec;\r\n}\r\n\r\nArithmetic auto<\/span> sub(Arithmetic auto<\/span> fir, Arithmetic auto<\/span> sec){  \/\/ (2)<\/span>\r\n    return<\/span> fir -<\/span> sec;\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The function sub<\/span> requires from its arguments fir<\/span> and sec,<\/span>  that both support the concept Arithmetic. <\/span>This means you can invoke sub(5.5, 5),<\/span> and it works with the function template (line 1) and the function (line 2). The return type is deduced according to arithmetic conversion rules in both cases. The concept Arithmetic<\/span> requires that fir<\/span> and sec<\/span> are either integral or floating-point numbers. Here is a straightforward implementation based on the type-traits function std::is_arithmetic<\/span><\/a>.<\/p>\n
\n
template<\/span><<\/span>typename<\/span> T><\/span> \r\nconcept Arithmetic =<\/span> std::<\/span>is_arithmetic<<\/span>T>::<\/span>value; \r\n<\/pre>\n<\/div>\n
A Difference between Concepts TS and Concepts Draft<\/h3>\n
I explicitly mentioned that both arguments could have different types with the Concepts Draft because this is different from the previous concepts syntax, supported by GCC. The previous syntax was based on the concepts TS (technical specification). In this syntax, the types of fir<\/span> and sec<\/span> have to be the same, and a call of the function sub(5.5, 5)<\/span> would fail. Additionally, the previous syntax required no additional auto<\/span> when concepts were used, and the definition of concepts was slightly more verbose.<\/p>\n
\n
\/\/ conceptsArithmeticTS.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> Arithmetic(){\r\n    return<\/span> std::<\/span>is_arithmetic<<\/span>T>::<\/span>value;\r\n}\r\n\r\nArithmetic sub(Arithmetic fir, Arithmetic sec){\r\n    return<\/span> fir -<\/span> sec;\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> \"sub(6, 5): \"<\/span> <<<\/span> sub(6<\/span>, 5<\/span>) <<<\/span> std::<\/span>endl;      \/\/ (1)<\/span>\r\n    std::<\/span>cout <<<\/span> \"sub(5.5, 5): \"<\/span> <<<\/span> sub(5.5<\/span>, 5<\/span>) <<<\/span> std::<\/span>endl;  \/\/ (2)<\/span>\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Because of line 2, the compilation of the program fails with the concepts TS.<\/p>\n
\"conceptsArithmeticTS\"<\/p>\n
Overloading<\/h3>\n
The abbreviated function templates syntax behaves as expected. The new syntax support overloading. As usual, the compiler chooses the best-fitting overload.<\/p>\n
\n
\/\/ conceptsOverloading.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 Integral =<\/span> std::<\/span>is_integral<<\/span>T>::<\/span>value;\r\n\r\nvoid<\/span> overload<\/span>(auto<\/span> t){\r\n    std::<\/span>cout <<<\/span> \"auto : \"<\/span> <<<\/span> t <<<\/span> std::<\/span>endl;\r\n}\r\n\r\nvoid<\/span> overload<\/span>(Integral auto<\/span> t){\r\n    std::<\/span>cout <<<\/span> \"Integral : \"<\/span> <<<\/span> t <<<\/span> std::<\/span>endl;\r\n}\r\n\r\nvoid<\/span> overload<\/span>(long<\/span> t){\r\n    std::<\/span>cout <<<\/span> \"long : \"<\/span> <<<\/span> t <<<\/span> std::<\/span>endl;\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    overload(3.14<\/span>);             \/\/ (1)<\/span>\r\n    overload(2010<\/span>);             \/\/ (2)<\/span>\r\n    overload(2020l<\/span>);            \/\/ (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
When invoked with a double<\/span> (line 1), an int (<\/span>line 2),<\/span> or a long int (line 3<\/span>)<\/span>, the best-fitting overload is chosen.<\/p>\n
\"conceptOverloading\"<\/p>\n
What’s next?<\/h2>\n
Two pieces are still missing in my series of concepts and are, therefore, the topic of my next posts<\/a> \u2014 the definition of concepts and the so-called template introduction, which is part of the concept TS.<\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
Today, my post is not about something new to concepts. It’s about syntactic sugar. I write about abbreviated function templates. What? Abbreviated function templates allow a sweet way to define templates.<\/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-5828","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\/5828","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=5828"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5828\/revisions"}],"predecessor-version":[{"id":6762,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5828\/revisions\/6762"}],"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=5828"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5828"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5828"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}