{"id":5821,"date":"2019-12-06T07:11:00","date_gmt":"2019-12-06T07:11:00","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-20-concepts-the-placeholder-syntax\/"},"modified":"2023-06-26T09:57:04","modified_gmt":"2023-06-26T09:57:04","slug":"c-20-concepts-the-placeholder-syntax","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-20-concepts-the-placeholder-syntax\/","title":{"rendered":"C++20: Concepts, the Placeholder Syntax"},"content":{"rendered":"

Today, I have a simple answer to a challenging question: Where can I use my concept? Concepts can be used where auto<\/span> is usable.<\/p>\n

<\/p>\n

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

Before I write about the placeholder syntax and the new way to define function templates, I must make a detour. We have asymmetries in C++11\/14.<\/p>\n

From Asymmetries in C++11\/14 to Symmetries in C++20<\/h2>\n

I often have discussions in my C++ seminars that goes like this.<\/p>\n

What is the Standard Template Library from the birds-eyes perspective? Generic containers can be manipulated with generic algorithms. The glue between these two disjunct components is iterators.<\/p>\n

\"stl\"<\/p>\n

 <\/p>\n

Generic containers and algorithms mean they are not bound to a specific type. Fine. Many of the algorithms can be parametrized by a callable. For example, std::sort<\/span><\/a> has an overload that takes a binary predicate (callable). This binary predicate is applied to the elements of the container. A binary predicate is a function that takes two arguments and returns a boolean. You can use a function, a function object, or with C++11 lambda as a binary predicate.<\/p>\n

The Small Asymmetry in C++11<\/h3>\n

What’s wrong with the following program? (I know that we have <\/span>the predefined predicate std::greater<\/a>.)<\/p>\n

<\/p>\n

\n
\/\/ lambdaCpp11.cpp<\/span>\r\n\r\n#include <algorithm><\/span>\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <array><\/span>\r\n#include <vector><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> Cont, typename<\/span> Pred><\/span>\r\nvoid<\/span> sortDescending(Cont&<\/span> cont, Pred pred){\r\n    std::<\/span>sort(cont.begin(), cont.end(), pred);\r\n}\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> Cont><\/span>\r\nvoid<\/span> printMe(const<\/span> Cont&<\/span> cont){\r\n    for<\/span> (auto<\/span> c:<\/span> cont) std::<\/span>cout <<<\/span> c <<<\/span> \" \"<\/span>;\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\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>array<<\/span>int<\/span>, 10<\/span>><\/span> myArray{5<\/span>, -<\/span>10<\/span>, 3<\/span>, 2<\/span>, 7<\/span>, 8<\/span>, 9<\/span>, -<\/span>4<\/span>, 3<\/span>, 4<\/span>};\r\n    std::<\/span>vector<<\/span>double<\/span>><\/span> myVector{5.1<\/span>, -<\/span>10.5<\/span>, 3.1<\/span>, 2.0<\/span>, 7.2<\/span>, 8.3<\/span>};\r\n    std::<\/span>vector<<\/span>std::<\/span>string><\/span> myVector2{\"Only\"<\/span>, \"for\"<\/span>, \"testing\"<\/span>, \"purpose\"<\/span>};\r\n    \r\n    sortDescending(myArray, [](int<\/span> fir, int<\/span> sec){ return<\/span> fir ><\/span> sec; });           \/\/ (1)<\/span>\r\n    sortDescending(myVector, [](double<\/span> fir, double<\/span> sec){ return<\/span> fir ><\/span> sec; });    \/\/ (2)<\/span>\r\n    sortDescending(myVector2, [](const<\/span> std::<\/span>string&<\/span> fir, const<\/span> std::<\/span>string&<\/span> sec){ \/\/ (3)<\/span>\r\n       return<\/span> fir ><\/span> sec; \r\n    });\r\n\r\n    printMe(myArray);\r\n    printMe(myVector);\r\n    printMe(myVector2);\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The program has a std::array<\/span> of int’<\/span>s, a std::vector<\/span> of double’<\/span>s, and a std::vector<\/span> of std::string<\/span>‘s. All containers should be sorted in descending order and displayed. To ease my job, I create the two function templates sortDescending<\/span> and printMe. <\/span><\/p>\n
\"lambdaCpp11\"<\/p>\n
Although containers and algorithms are generic, C++11 has only type-based lambdas. I have to implement the binary predicate for each data type (lines 1 – 3) and break, therefore, my generic approach.<\/p>\n
With C++14, this asymmetry disappears. Containers and algorithms are generic, and lambdas can be generic.<\/p>\n<\/p>\n
The Big Asymmetry in C++14<\/h3>\n
C++14 implements the previous program lambdaCpp11.cpp<\/span> straightforward.<\/p>\n
<\/p>\n
\n
\/\/ lambdaCpp14.cpp<\/span>\r\n\r\n#include <algorithm><\/span>\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <array><\/span>\r\n#include <vector><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> Cont><\/span>\r\nvoid<\/span> sortDescending(Cont&<\/span> cont){\r\n    std::<\/span>sort(cont.begin(), cont.end(), [](auto<\/span> fir, auto<\/span> sec){   \/\/ (1)<\/span>\r\n        return<\/span> fir ><\/span> sec; \r\n    });\r\n}\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> Cont><\/span>\r\nvoid<\/span> printMe(const<\/span> Cont&<\/span> cont){\r\n    for<\/span> (auto<\/span> c:<\/span> cont) std::<\/span>cout <<<\/span> c <<<\/span> \" \"<\/span>;\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\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>array<<\/span>int<\/span>, 10<\/span>><\/span> myArray{5<\/span>, -<\/span>10<\/span>, 3<\/span>, 2<\/span>, 7<\/span>, 8<\/span>, 9<\/span>, -<\/span>4<\/span>, 3<\/span>, 4<\/span>};\r\n    std::<\/span>vector<<\/span>double<\/span>><\/span> myVector{5.1<\/span>, -<\/span>10.5<\/span>, 3.1<\/span>, 2.0<\/span>, 7.2<\/span>, 8.3<\/span>};\r\n    std::<\/span>vector<<\/span>std::<\/span>string><\/span> myVector2{\"Only\"<\/span>, \"for\"<\/span>, \"testing\"<\/span>, \"purpose\"<\/span>};\r\n    \r\n    sortDescending(myArray);      \/\/ (2)<\/span>\r\n    sortDescending(myVector);     \/\/ (2)<\/span>\r\n    sortDescending(myVector2);    \/\/ (2)<\/span>\r\n\r\n    printMe(myArray);\r\n    printMe(myVector);\r\n    printMe(myVector2);\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
<\/span><\/p>\n
Fine? Yes and No. Yes, because I can use a generic lambda (line 1) for each data type in line 2. No, because I replaced one slight asymmetry in C++11 with a bigger asymmetry in C++14. The slight asymmetry in C++11 was that a lambda is type-bound. The big asymmetry in C++14 is that generic lambda introduced a new syntactic form to write generic functions, better known as function templates. Here is the proof:<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ genericLambdaTemplate.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\ntemplate<\/span> <<\/span>typename<\/span> T, typename<\/span> T2><\/span>                            \/\/ (2)<\/span>\r\nauto<\/span> addTemplate(T fir, T2 sec){ return<\/span> fir +<\/span> sec; }\r\n\r\nint<\/span> main(){\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> addTemplate(1<\/span>, 5<\/span>) <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> addLambda(true<\/span>, 5<\/span>) <<<\/span> \" \"<\/span> <<<\/span> addTemplate(true<\/span>, 5<\/span>) <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> addLambda(1<\/span>, 5.5<\/span>) <<<\/span> \" \"<\/span> <<<\/span> addTemplate(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> addTemplate(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 generic lambda in line 1 and the function template in line 2 produce the same results.<\/p>\n
\"genericLambdaTemplate\"<\/p>\n
This is the asymmetry in C++14. Generic lambdas introduce a new way to define function templates.<\/p>\n
When I teach this in my seminars, I almost always get the question: Can we use auto<\/span> in functions to get function templates? No with C++17, but yes with C++20.  In C++20, you can use constrained placeholders (concepts) or unconstrained placeholders (auto)<\/span> in function declarations to get function templates. This means the asymmetry in C++ is gone with C++20.<\/p>\n
The Solution in C++20<\/h3>\n
Before I write about the new definition of function templates, I want to answer my original question: Where can I use my concept? Concepts can be used where auto<\/span> is usable.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ placeholdersDraft.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <type_traits><\/span>\r\n#include <vector><\/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\nIntegral auto<\/span> getIntegral<\/span>(int<\/span> val){                    \/\/ (2)<\/span>\r\n    return<\/span> val;\r\n}\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>vector<<\/span>int<\/span>><\/span> vec{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\r\n    for<\/span> (Integral auto<\/span> i:<\/span> vec) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;  \/\/ (3)<\/span>\r\n \r\n    Integral auto<\/span> b =<\/span> true<\/span>;                            \/\/ (4)<\/span>\r\n    std::<\/span>cout <<<\/span> b <<<\/span> std::<\/span>endl;\r\n\r\n    Integral auto<\/span> integ =<\/span> getIntegral(10<\/span>);             \/\/ (5)<\/span>\r\n    std::<\/span>cout <<<\/span> integ <<<\/span> std::<\/span>endl;\r\n\r\n    auto<\/span> integ1 =<\/span> getIntegral(10<\/span>);                     \/\/ (6)<\/span>\r\n    std::<\/span>cout <<<\/span> integ1 <<<\/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 concept Integral<\/span> in line 1 can be used as a return type (line 2), in a range-based for-loop (line 3), or as a type for the variable b<\/span> (line 4) or the variable integ <\/span>(line 5). To see the symmetry, line 6 uses type-deduction with auto<\/span> instead. I have to admit that no compiler is now available to compile the proposed concepts syntax I used in my example. The following output is, therefore, from GCC and the previous Concepts Technical Specification (Concepts TS).<\/p>\n
\"conceptsPlaceholder\"<\/p>\n
What’s next?<\/h2>\n
My next post <\/a>concerns the syntactic sugar we get with constrained placeholders (concepts) and unconstrained placeholders (auto) in C++20. I assume the function (template) getIntegral<\/span> gives you a first impression.<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
Today, I have a simple answer to a challenging question: Where can I use my concept? Concepts can be used where auto is usable.<\/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-5821","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\/5821","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=5821"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5821\/revisions"}],"predecessor-version":[{"id":6763,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5821\/revisions\/6763"}],"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=5821"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5821"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5821"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}