{"id":5218,"date":"2017-03-11T09:06:31","date_gmt":"2017-03-11T09:06:31","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/placeholders-the-second\/"},"modified":"2023-06-26T12:19:35","modified_gmt":"2023-06-26T12:19:35","slug":"placeholders-the-second","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/placeholders-the-second\/","title":{"rendered":"Placeholders – The Second"},"content":{"rendered":"

The unification of templates, concepts, and placeholders goes on. This time, I will look closely at constrained (concepts) and unconstrained (auto)<\/span> placeholders in the context of templates.<\/p>\n

<\/p>\n

 <\/p>\n

First, a short reminder for you (and me). I stated in my last post Concepts -Placeholders<\/a>: You can use constrained placeholders (concepts) in each situation, whereas you can use unconstrained placeholders (auto).<\/span> I used in the last post the concept Integral<\/span> in the algorithm gcd<\/span> to make it more type-safe. Let’s continue.
<\/span><\/p>\n

Syntactic sugar and more<\/h2>\n

 <\/p>\n

<\/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\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53<\/pre>\n<\/td>\n
\n
\/\/ conceptsIntegralVariations.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\ntemplate<\/span><Integral T>\r\nT gcd1(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\nIntegral gcd2(Integral a, Integral 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\nauto<\/span> gcd3(auto<\/span> a, auto<\/span> 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 << \"gcd1(100, 10)= \"<\/span> <<  gcd1(100, 10)  << std::endl;\r\n  std::cout << \"gcd2(100, 10)= \"<\/span> <<  gcd2(100, 10)  << std::endl;\r\n  std::cout << \"gcd3(100, 10)= \"<\/span> <<  gcd3(100, 10)  << 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
Don’t get me wrong. I’m a big fan of syntactic sugar<\/a>. Syntactic sugar makes a feature easier to use, and you can write more expressive and less error-prone code. Isn’t C++ only syntactic sugar for C or assembler?<\/p>\n
I define in lines 7 -9 the concept Integral<\/span> that I use in the algorithm gcd<\/span> (lines 11 – 18). Now,  I make the syntax sweeter. Instead of specifying the concept in the required clause (line 12), I can use it instead of the keyword typename<\/span> or class<\/span> for the type parameter (line 20). It gets even sweeter\u2014the concept Integral<\/span> is used in line 28 as a function parameter. Of course, gcd2<\/span> becomes, by using the concept, a function template. Now the unification kicks in. I will get an unconstrained function template if I replace a constrained placeholder (Integral) in line 28 with the unconstrained placeholders (auto) in line 35.<\/em> Sorry about my newly coined term, unconstrained function template. I mean, gcd3<\/span> is a template that can accept values of arbitrary type.<\/p>\n
To wrap up my sentences, here is the output of the program.<\/p>\n
 \"conceptsIntegralVariations\"<\/p>\n
I called this section “Syntactic sugar and more”. But why more? You will see.<\/p>\n<\/p>\n
Syntactic sugar and more<\/strong><\/h3>\n
The function template gcd2<\/span> is more potent than the function template gcd<\/span> or gcd1.<\/span> gcd2<\/span> has two type parameters that have not to be the same. Both have to respect the concept of Integral. The same observations hold for the function template gcd3.<\/span> a<\/span> and b<\/span> have not to be of the same type. Using the function template twoTypes<\/span> in line 39 makes my point clear.<\/p>\n
 <\/p>\n
<\/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\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43<\/pre>\n<\/td>\n
\n
\/\/ placeholders.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <typeinfo><\/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\nvoid<\/span> overload(auto<\/span> t){\r\n  std::cout << \"auto : \"<\/span> << t << std::endl;\r\n}\r\n\r\nvoid<\/span> overload(Integral t){\r\n  std::cout << \"Integral : \"<\/span> << t << std::endl;\r\n}\r\n\r\nvoid<\/span> overload(long<\/span> t){\r\n  std::cout << \"long : \"<\/span> << t << std::endl;\r\n}\r\n  \r\nvoid<\/span> twoTypes(auto<\/span> a, auto<\/span> b){\r\n  std::cout << typeid<\/span>(a).name() << std::endl;\r\n  std::cout << typeid<\/span>(b).name() << std::endl;\r\n}\r\n\r\n\r\nint<\/span> main(){\r\n  \r\n  std::cout << std::endl;\r\n  \r\n  overload(3.14);\r\n  overload(2010);\r\n  overload(2020l);\r\n  \r\n  std::cout << std::endl;\r\n  \r\n  twoTypes(2010, 3.14); \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
 With a little bit of R<\/strong>un T<\/strong>ime T<\/strong>ype I<\/strong>nfomation (RTTI)<\/a> in line 24 and 25, I get a string representation of the types. As expected, the types are int<\/span> and double. <\/span><\/p>\n
\"placeholders\"<\/p>\n
But the short example shows more. The interplay between the unconstrained function template (line 11), the constrained function template (line 15), and the function (line 19) is very smooth. That is precisely the behavior, I expected.<\/p>\n
If you hate the classical way of declaring templates, there is a new way.<\/p>\n
Template introduction<\/h2>\n
Instead of declaring your constrained template by using template<Integral T><\/span>, you can now just right Integral{T}<\/span>. Once more, I wrote constrained templates. So, you have to use concepts. <\/p>\n
 <\/p>\n
<\/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\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49<\/pre>\n<\/td>\n
\n
\/\/ templateIntroduction.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\nIntegral{T}\r\nIntegral 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\nIntegral{T} \r\nclass<\/span> ConstrainedClass<\/span>{};\r\n\r\n\/*<\/span>\r\n\r\nauto{T}<\/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} <\/span>\r\nclass ConstrainedClass{};<\/span>\r\n\r\n*\/<\/span>\r\n\r\n\r\nint<\/span> main(){\r\n  \r\n  std::cout << std::endl;\r\n  \r\n  auto<\/span> res= gcd(100, 10); \r\n\r\n  ConstrainedClass<int<\/span>> constrainedClass;\r\n  ConstrainedClass<double<\/span>> constrainedClass1;\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 used the new syntax for the function template gcd<\/span> in line 11 and the class-template ConstrainedClass<\/span> in line 19<\/span>. The concept will kick in if I try to instantiate ConstraintedClass<\/span> for double<\/span> (line 45).<\/p>\n
\"templateIntroductionError\"<\/p>\n
I don’t like that I can not replace Integral<\/span> with auto<\/span>, such as in lines 24 to 33. In my posts, I have used a constrained placeholder instead of an unconstrained placeholder and the other way around. That is a simple principle.<\/p>\n
Of course, I can overcome this restriction by using a concept that constantly evaluates to true.<\/span><\/p>\n
 <\/p>\n
<\/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\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45<\/pre>\n<\/td>\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\n\r\ntemplate<\/span><typename<\/span> T>\r\nconcept bool<\/span> Generic(){\r\n  return<\/span> true;\r\n}\r\n\r\nGeneric{T}\r\nGeneric 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\nGeneric{T} \r\nclass<\/span> ConstrainedClass<\/span>{\r\npublic:\r\n  ConstrainedClass(){\r\n    std::cout << typeid<\/span>(decltype(std::declval<T>())).name() << std::endl;\r\n  }\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  \r\n  std::cout << std::endl;\r\n \r\n  ConstrainedClass<int<\/span>> genericClassInt;\r\n  ConstrainedClass<std::string> genericClassString;\r\n  ConstrainedClass<double<\/span>> genericClassDouble;\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
Generic<\/span> (lines 9 – 12) is my concept that returns true<\/span> for all types. Now, I can unify the syntax and define an unconstrained function template (lines 14 – 20) and an unconstrained class template (lines 22 – 28). Sorry for the expression typeid(decltype(std::declval<T>())).name()<\/span> in line 26 that works even for a type T without a default constructor. This expression returns the string representation of the type parameter T. Here is the program’s output. <\/p>\n
\"templateIntroductionGeneric\"<\/p>\n
What’s next?<\/h2>\n
I always use the same concept Integral<\/span>, in my examples. Bored? That will change. I will write in my next post<\/a> about defining concepts.<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
The unification of templates, concepts, and placeholders goes on. This time, I will look closely at constrained (concepts) and unconstrained (auto) placeholders in the context of templates.<\/p>\n","protected":false},"author":21,"featured_media":5214,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[365],"tags":[415,482],"class_list":["post-5218","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-functional","tag-concepts","tag-outdated"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5218","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=5218"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5218\/revisions"}],"predecessor-version":[{"id":6878,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5218\/revisions\/6878"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5214"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5218"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5218"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5218"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}