![\"TimelineCpp20Concepts\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/11\/TimelineCpp20Concepts.png\")
<\/p>\nLet me conclude my series to concepts with this meta-post. Are concepts an evolution or a revolution in C++? The answer to this question bothered me quite a time.<\/p>\n
<\/p>\n
<\/p>\n
I assume we all know what evolution or revolution means, but let me be more precise. These definitions are quite concise:<\/p>\n
To make it short. The crucial difference between evolution and revolution is if the change is gradual (evolution) or disruptive (revolution).<\/p>\n
I had many discussions in the series about concepts. Consequentially, I was curious about what your opinion of concepts is. The answers I got are in German. For your convenience, I paraphrase it in English. Interestingly, my readers have a clear tendency to evolve. Honestly, I’m more on the revolution side.<\/p>\n
Which argument speaks for evolution, and which argument speaks for revolution?<\/p>\n
![\"evolution](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2020\/02\/evolution-4107273_1280.jpg\")
<\/p>\n
Image by Alexas_Fotos<\/a> from Pixabay<\/a><\/p>\n<\/p>\n When appropriately used, concepts should promote clean working with generic code at a higher level of abstraction.<\/p>\n In the longer term, the standard concepts should become increasingly idiomatic in C++. The interoperability and modular work, especially in larger teams, can be made more robust and less prone to errors if more abstract properties of the parameter classes are checked and less for purely syntactic “rollout” in generic code.<\/p>\n You cannot do anything that you would not have been able to do with type-traits library<\/a>, SFINAE<\/a>, and static_assert<\/a> so far, even if it was very cumbersome and time-consuming. Their advantages lie in the simple definition and meaningful error messages.<\/p>\n Since C++11, we have auto to deduce the type of a variable from its initializer.<\/p>\n <\/p>\n <\/span><\/p>\n auto<\/span> is a kind of unconstrained placeholder. With C++20, we can use concepts as constrained placeholders.<\/p>\n <\/p>\n <\/p>\n <\/p>\n To make it concise and evolutionary: you can use a constrained placeholder (concept) in each place you could use an unconstrained placeholder (auto).<\/p>\n With C++14, you can use a generic lambda (addLambda<\/span>), which essentially becomes a function template (addTemplate).<\/p>\n <\/p>\n <\/p>\n Using auto<\/span> in a function declaration was not possible with C++14. Since C++20, you can use a constrained placeholder (concept) or an unconstrained placeholder (auto<\/span>) in a function declaration, and the function declaration becomes a function template with unconstrained (auto<\/span>) or constrained (concept) parameters.<\/p>\n <\/p>\n <\/p>\n To make my point, I intentionally used a strange signature for my addConstrained function. <\/p>\n <\/p>\n Image by WikiImages<\/a> from Pixabay<\/a><\/p>\n Admittedly, you can specify template requirements in C++11 in the template declaration.<\/p>\n <\/p>\n <\/p>\n The function template moduloOf<\/span> requires that the T<\/span> has to be integral. If T is not integral and the expression std::is_integral<T>::value<\/span> evaluates to false<\/span>, the failed substitution is not an error. The compiler removes the overload from the set of all potential overloads. After that step, there is no valid overload left.<\/p>\n This technique is called SFINAE and stands for S<\/strong>ubstitution F<\/strong>ailure I<\/strong>s N<\/strong>ot A<\/strong>n E<\/strong>rror. <\/p>\n Honestly, I only teach this technique in template classes. This does not hold for concepts. The issue becomes immediately obvious.<\/p>\n <\/p>\n <\/p>\n <\/p>\n Thanks to the abbreviated function template syntax, the definition of a function template becomes a piece of cake. I already presented the new syntactic sugar in the function declarations of addConstrained<\/span>, and moduloOf. <\/span>Therefore, I skip the example.<\/span><\/p>\n Concepts do not stand for syntactic constraints but for semantic categories. <\/p>\n Addable<\/span> is a concept that stands for a syntactic constraint.<\/p>\n <\/p>\n <\/p>\n <\/p>\n I assume Addable<\/span> behaves not like expected. The function template <\/span>Clear Abstraction <\/span><\/h3>\n
<\/span>Simple Definition and Meaningful Error Messages<\/span><\/h3>\n
<\/span>Unconstrained Placeholders<\/span><\/h3>\n
\nauto<\/span> integ =<\/span> add(2000<\/span>, 11<\/span>);\r\n\r\nstd::<\/span>vector<<\/span>int<\/span>><\/span> myVec{1<\/span>, 2<\/span>, 3<\/span>};\r\nfor<\/span> (auto<\/span> v:<\/span> myVec) std::<\/span>cout <<<\/span> v <<<\/span> std::<\/span>endl;\r\n<\/pre>\n<\/div>\n\ntemplate<\/span><<\/span>typename<\/span> T><\/span> \r\nconcept Integral =<\/span> std::<\/span>is_integral<<\/span>T>::<\/span>value;\r\n\r\nIntegral auto<\/span> integ =<\/span> add(2000<\/span>, 11<\/span>);\r\n\r\nstd::<\/span>vector<<\/span>int<\/span>><\/span> myVec{1<\/span>, 2<\/span>, 3<\/span>};\r\nfor<\/span> (Integral auto<\/span> v:<\/span> myVec) std::<\/span>cout <<<\/span> v <<<\/span> std::<\/span>endl;\r\n<\/pre>\n<\/div>\n<\/span>Generic Lambdas<\/span><\/h3>\n
\n\/\/ addLambdaGeneric.pp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nauto<\/span> addLambda =<\/span> [](auto<\/span> fir, auto<\/span> sec){ return<\/span> fir +<\/span> sec; }; \r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T, typename<\/span> T2><\/span> \r\nauto<\/span> addTemplate(T fir, T2 sec){ return<\/span> fir +<\/span> sec; }\r\n\r\n\r\nint<\/span> main(){\r\n \r\n std::<\/span>cout <<<\/span> addLambda(2000<\/span>, 11.5<\/span>); \/\/ 2011.5<\/span>\r\n std::<\/span>cout <<<\/span> addTemplate(2000<\/span>, 11.5<\/span>); \/\/ 2011.5<\/span>\r\n \r\n}\r\n<\/pre>\n<\/div>\n\n\/\/ addUnconstrainedConstrained.cpp<\/span>\r\n\r\n#include <concepts><\/span>\r\n#include <iostream><\/span>\r\n\r\nauto<\/span> addUnconstrained<\/span>(auto<\/span> fir, auto<\/span> sec){\r\n return<\/span> fir +<\/span> sec;\r\n}\r\n\r\nstd::<\/span>floating_point auto<\/span> addConstrained(std::<\/span>integral auto<\/span> fir, \r\n std::<\/span>floating_point auto<\/span> sec){\r\n return<\/span> fir +<\/span> sec;\r\n}\r\n\r\nint<\/span> main(){\r\n \r\n std::<\/span>cout <<<\/span> addUnconstrained(2000<\/span>, 11.5<\/span>); \/\/ 2011.5<\/span>\r\n std::<\/span>cout <<<\/span> addConstrained(2000<\/span>, 11.5<\/span>); \/\/ 2011.5<\/span>\r\n \r\n}\r\n<\/pre>\n<\/div>\n<\/span>Revolution<\/span><\/h2>\n
![\"france](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2020\/02\/france-63022_1280.jpg\")
<\/p>\n<\/span>Template Requirements are verified<\/span><\/h3>\n
\n\/\/ requirementsCheckSFINAE.cpp<\/span>\r\n\r\n#include <type_traits><\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T,\r\n typename<\/span> std::<\/span>enable_if<<\/span>std::<\/span>is_integral<<\/span>T>::<\/span>value, T>::<\/span> type =<\/span> 0<\/span>><\/span>\r\nT moduloOf(T t) {\r\n return<\/span> t %<\/span> 5<\/span>;\r\n}\r\n\r\nint<\/span> main() {\r\n\r\n auto<\/span> res =<\/span> moduloOf(5.5<\/span>);\r\n\r\n}\r\n<\/pre>\n<\/div>\n![\"SFINAE\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2020\/02\/SFINAE.png\")
<\/p>\n\n\/\/ requirementsCheckConcepts.cpp<\/span>\r\n\r\n#include <concepts><\/span>\r\n\r\nstd::<\/span>integral auto<\/span> moduloOf(std::<\/span>integral auto<\/span> t) {\r\n return<\/span> t %<\/span> 5<\/span>;\r\n}\r\n\r\nint<\/span> main() {\r\n\r\n auto<\/span> res =<\/span> moduloOf(5.5<\/span>);\r\n\r\n}\r\n<\/pre>\n<\/div>\n![\"conceptsError\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2020\/02\/conceptsError.png\")
<\/p>\n<\/span>The Definition of Templates radically improved<\/span><\/h3>\n
<\/span>Semantic Categories<\/span><\/h3>\n
\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nconcept Addable =<\/span> has_plus<<\/span>T><\/span>; \/\/ bad; insufficient<\/span>\r\n\r\ntemplate<\/span><<\/span>Addable N><\/span> auto<\/span> algo(const<\/span> N&<\/span> a, const<\/span> N&<\/span> b) \/\/ use two numbers<\/span>\r\n{\r\n \/\/ ...<\/span>\r\n return<\/span> a +<\/span> b;\r\n}\r\n\r\nint<\/span> x =<\/span> 7<\/span>;\r\nint<\/span> y =<\/span> 9<\/span>;\r\nauto<\/span> z =<\/span> algo(x, y); \/\/ z = 16<\/span>\r\n\r\nstd::string xx =<\/span> \"7\"<\/span>;\r\nstd::string yy =<\/span> \"9\"<\/span>;\r\nauto<\/span> zz =<\/span> algo(xx, yy); \/\/ zz = \"79\"<\/span>\r\n<\/pre>\n<\/div>\nalgo<\/code> should accept arguments that model numbers and not just support the + operator. Consequentially, two strings can be used as arguments. This is bad because addition is commutative, but not string concatenation: “7” + “9” != “9” + “7”.<\/span><\/p>\n