{"id":5213,"date":"2017-03-05T16:54:32","date_gmt":"2017-03-05T16:54:32","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/concepts-placeholders\/"},"modified":"2023-06-26T12:20:07","modified_gmt":"2023-06-26T12:20:07","slug":"concepts-placeholders","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/concepts-placeholders\/","title":{"rendered":"Concepts – Placeholders"},"content":{"rendered":"

C++11 has auto unconstrained placeholders. You can use concepts in C++20 as constrained placeholders. What seems at first glimpse not so thrilling is for me the decisive quantum leap. C++ templates will become an easy to use C++ feature.<\/p>\n

<\/p>\n

Before I present the new syntax, I have to make a short remark. After my research to concepts and my experiments with unconstrained and constrained placeholders, I’m very biased. Therefore you can not expect a quite objective post.   <\/em><\/p>\n

An ever and ever-recurring question<\/h2>\n

I hear often in my C++ and Python seminars the question: When is a programming language easy? Of course, the answer can not be that a programming language is easy if you can solve difficult questions in an easy way. That is a contradiction.<\/p>\n

For me, a programming language is easy if you can reduce it to a few simple principles. I call such a principle a red thread<\/b>. I hope you get the German proverb. The idea of these few simple principles is that you can deduce the features of the language from these principles. According to my definition, Python is a simple programming language. For example, if you get the idea of building slices on a sequence, you can apply this principle in many contexts.<\/p>\n

\"slice\"<\/p>\n

Therefore, the syntax will follow the same principle if I want to return each third element of a just-in-place created range range(0,10,3),<\/span> a string,  a list, or a tuple. The same principle will hold if I return the second element of a just-in-place created range range(9,0,-2)<\/span>,  a string, a list or a tuple in reverse order.<\/p>\n

According to my definition, C++98 is not a simple language. C++11 is something in between. For example, we have rules such as you can initialize all with curly braces (see { } – Initialization<\/a>). Of course, even C++14 has a lot of features where I miss a simple principle. One of my favourites is the generalised lambda function.<\/p>\n

\n\n\n\n
\n
1\r\n2\r\n3\r\n4\r\n5\r\n6<\/pre>\n<\/td>\n
\n
auto<\/span> genLambdaFunction= [](auto<\/span> a, auto<\/span> b) { return<\/span> a < b; };\r\n\r\ntemplate<\/span> <typename<\/span> T, typename<\/span> T2>\r\nauto<\/span> genFunction(T a, T2 b){\r\n  return<\/span> a < b;\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
By using the placeholder auto<\/span> for the parameter a<\/span> and b <\/span>the generalised lambda function becomes in a magic way a function template. (I know, genLambdaFunction<\/span> is a function object that has an overloaded call operator which accepts two type parameters.). genFunction<\/span> is also a function template but you can not just define it by using auto<\/span>. Hence you have to use a lot more syntax (line 3 and 4). That is the syntax which is often too difficult for a lot of C++ programmer. <\/p>\n
Exactly that asymmetry will be removed with the placeholder syntax. Therefore, we have a new simple principle and C++ will become – according to my definition – a lot easier to use.<\/p>\n<\/p>\n
Placeholders<\/h2>\n
We will get unconstrained and constrained placeholders. auto<\/span> is an unconstrained placeholder because a auto<\/span> defined variable can be of any type. A concept is a constrained placeholder because it can only be used to define a variable that satisfies the concept. I introduced concepts in the post Concepts<\/a> with the help of Haskell’s type classes. I got international praise and blame for my approach.<\/p>\n
Let me define and use a simple concept before I dig into the details.<\/p>\n
A simple concept<\/h3>\n
Thanks to the concept Integral<\/span>, the arguments of my gcd algorithm have to be integrals.<\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30<\/pre>\n<\/td>\n
\n
\/\/ conceptsIntegral.cpp<\/span>\r\n\r\n#include <type_traits><\/span>\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span><typename<\/span> T>\r\nconcept bool<\/span> Integral(){\r\n  return<\/span> std::is_integral<T>::value;\r\n}\r\n\r\ntemplate<\/span><typename<\/span> T>\r\nrequires Integral<T>()\r\nT gcd(T a, T b){\r\n  if<\/span>( b == 0 ){ return<\/span> a; }\r\n  else<\/span>{\r\n    return<\/span> gcd(b, a % b);\r\n  }\r\n}\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  std::cout << \"gcd(100, 10)= \"<\/span> <<  gcd(100, 10)  << std::endl;\r\n  std::cout << \"gcd(100, 33)= \"<\/span> << gcd(100, 33) << std::endl;\r\n  \/\/ std::cout << \"gcd(5.5, 4,5)= \" << gcd(5.5, 4.5) << std::endl;<\/span>\r\n\r\n  std::cout << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
I define in line 6 the concept  Integral.<\/span> The concept Integral<\/span> will evaluate to true if the predicate std::is_integral<T>::value returns true<\/span> for T. std::is_integral<T><\/span> is a function of the type-traits library. The functions of the type-traits library enable amongst other things that you can check types at compile time. You can read the details about the type-traits in the posts about the type-traits library<\/a>.  In particular,  I used the functions of the type-traits library to make the gcd algorithm more and more type-safe: More and More Save<\/a>. I applied the concept in line 12. I will write in my next post how you can apply a concept in a simpler way. Therefore, the border between function templates and function successively distinguish.<\/p>\n
But now, back to my small example. Thanks to the relatively new GCC 6.3 and the compiler flag -fconcepts<\/span>, I can compile and run the program.<\/p>\n
\"conceptsIntegral\"<\/p>\n
What will happen if I use line 26? The concept kicks in.<\/p>\n
\"conceptsIntegralError\"<\/p>\n
Once more, back to the placeholders. To be specific, constrained and unconstrained placeholders.<\/p>\n
Constrained and unconstrained placeholders<\/h3>\n
You can use constrained placeholders (concepts) in each situation where you can use unconstrained placeholders (auto<\/span>). If this is not an intuitive rule?<\/strong><\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35<\/pre>\n<\/td>\n
\n
\/\/ conceptsPlaceholder.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><typename<\/span> T>\r\nconcept bool<\/span> Integral(){\r\n  return<\/span> std::is_integral<T>::value;\r\n}\r\n\r\nIntegral getIntegral(auto<\/span> val){\r\n  return<\/span> val;\r\n}\r\n\r\nint<\/span> main(){\r\n  \r\n  std::cout << std::boolalpha << std::endl;\r\n  \r\n  std::vector<int<\/span>> myVec{1, 2, 3, 4, 5};\r\n  for<\/span> (Integral& i: myVec) std::cout << i << \" \"<\/span>;\r\n  std::cout << std::endl;  \r\n\r\n  Integral b= true;\r\n  std::cout << b << std::endl;\r\n  \r\n  Integral integ= getIntegral(10);\r\n  std::cout << integ << std::endl;\r\n  \r\n  auto<\/span> integ1= getIntegral(10);\r\n  std::cout << integ1 << std::endl;\r\n  \r\n  std::cout << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
For simplicity reasons, I reuse the concept Integral<\/span> in line 7 – 10. Hence I iterate over integrals in the range-based for-loop in line 21 and my variable b<\/span> in line 24 has to be integral. My usage of concepts goes on in line 27 and 30. I require in line 27 that the return type of getIntegral(10)<\/span> has to fulfil the concept Integral<\/span>.  I’m not so strict in line 30. Here I’m fine with an unconstrained placeholder.<\/p>\n
In the end, as ever, the output of the program. There was no surprise. Concepts behave totally intuitive.<\/p>\n
\"conceptsPlaceholder\"<\/p>\n
That’s the end of my post. Of course, it’s not! <\/b>I guess most of you didn’t recognise that I secretly introduced a new key feature of placeholders. Have a close look at the function getIntegral<\/span> (line 12).<\/p>\n
\n
Integral getIntegral(auto<\/span> val){\r\n  return<\/span> val;\r\n}\r\n<\/pre>\n<\/div>\n
The concept Integral<\/span> as the return type is quite easy to get because it’s possible to use unconstrained placeholders as return type since C++11. With C++20, we can use – according to the simple rule – constrained placeholders. My point is a different one. I use auto<\/span> for the type of the parameter. That is only possible for generalised lambda functions (see the first example). A generalised lambda function is under the hood a function template. Now, I will come back to my red thread. getIntegral<\/span> becomes due to the auto parameter a function template<\/span>.<\/strong>  That is happening without the usual function template syntax. getIntegral<\/span> accepts arbitrary types and returns only values of a type that fulfils the concept Integral<\/span>.<\/p>\n
What’s next?<\/h2>\n
In the next post<\/a>, I will continue my story about placeholders because the unification of templates, concepts, and placeholders goes on.<\/p>\n
 <\/p>\n
 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
C++11 has auto unconstrained placeholders. You can use concepts in C++20 as constrained placeholders. What seems at first glimpse not so thrilling is for me the decisive quantum leap. C++ templates will become an easy to use C++ feature.<\/p>\n","protected":false},"author":21,"featured_media":5209,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[365],"tags":[415],"class_list":["post-5213","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-functional","tag-concepts"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5213","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=5213"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5213\/revisions"}],"predecessor-version":[{"id":6879,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5213\/revisions\/6879"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5209"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5213"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5213"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5213"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}