{"id":5515,"date":"2018-09-18T22:46:16","date_gmt":"2018-09-18T22:46:16","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-core-guidelines-rules-for-the-usage-of-concepts\/"},"modified":"2023-06-26T11:44:38","modified_gmt":"2023-06-26T11:44:38","slug":"c-core-guidelines-rules-for-the-usage-of-concepts","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-core-guidelines-rules-for-the-usage-of-concepts\/","title":{"rendered":"C++ Core Guidelines: Better Specific or Generic?"},"content":{"rendered":"

Concepts revolutionize the way we think about and use generic programming. They didn’t make it in C++11 or C++17 but with C++20, we will get them with a high probability.<\/p>\n

<\/p>\n

\"roads<\/p>\n

Before I write about using concepts, I want to make a general remark.<\/p>\n

Too Specific versus Too Generic<\/h2>\n

Until C++20 we have in C++ two diametral ways to think about functions or user-defined types (classes). Functions or classes can be defined on specific types or on generic types. In the second case, we call them function or class templates. What are the downsides of each way?<\/p>\n

Too Specific<\/h3>\n

It’s quite a job to define a function or class for each specific type. To avoid that burden, type conversion often comes to our rescue but it is also part of the problem. Let’s see what I mean.<\/p>\n

Narrowing Conversion<\/h4>\n

You have a function getInt(int a)<\/code> that you can invoke with a double<\/code>. Now, narrowing conversion takes place.<\/p>\n

\n
\/\/ narrowingConversion.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nvoid<\/span> needInt<\/span>(int<\/span> i){\r\n    std::<\/span>cout <<<\/span> \"int: \"<\/span> <<<\/span> i <<<\/span> std::<\/span>endl;\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n\t\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\t\r\n\tdouble<\/span> d{1.234<\/span>};\r\n\tstd::<\/span>cout <<<\/span> \"double: \"<\/span> <<<\/span> d <<<\/span> std::<\/span>endl;\r\n\t\r\n\tneedInt(d);\r\n\t\r\n\tstd::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\t\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I assume that is not the behavior you wanted. You started with a double<\/code> and ended with an int<\/code>.<\/p>\n
\"narrowingConversion\"<\/p>\n
But conversion works also the other way around.<\/p>\n
Integral Promotion<\/h4>\n
You have a user-defined type MyHouse<\/code>. <\/span>An instance of MyHouse<\/code> can be constructed in two ways. When invoked without an argument (1), its attribute family<\/code> is set to an empty string. This means the house is still empty.  To easily check if the house is empty or full, I implemented a conversion operator to bool <\/code>(2). Fine or? No!<\/p>\n
\n
\/\/ conversionOperator.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n\r\nstruct<\/span> MyHouse{\r\n    MyHouse() =<\/span> default<\/span>;                            \/\/ (1)<\/span>\r\n    MyHouse(const<\/span> std::<\/span>string&<\/span> fam):<\/span> family(fam){}\r\n\t\r\n    operator<\/span> bool<\/span>(){ return<\/span> !<\/span>family.empty(); }      \/\/ (2)                         <\/span>\r\n\t\r\n    std::<\/span>string family =<\/span> \"\"<\/span>;\r\n};\r\n\r\nvoid<\/span> needInt<\/span>(int<\/span> i){\r\n    std::<\/span>cout <<<\/span> \"int: \"<\/span> <<<\/span> i <<<\/span> std::<\/span>endl;\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n\t\r\n    std::<\/span>cout <<<\/span> std::<\/span>boolalpha <<<\/span> std::<\/span>endl;\r\n\t\r\n    MyHouse firstHouse;\r\n    if<\/span> (!<\/span>firstHouse){                                        \r\n        std::<\/span>cout <<<\/span> \"The firstHouse is still empty.\"<\/span> <<<\/span> std::<\/span>endl;\r\n    };\r\n\t\r\n    MyHouse secondHouse(\"grimm\"<\/span>);                               \r\n    if<\/span> (secondHouse){\r\n        std::<\/span>cout <<<\/span> \"Family grimm lives in secondHouse.\"<\/span> <<<\/span> std::<\/span>endl;\r\n    }\r\n\t\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\t\r\n    needInt(firstHouse);              \/\/ (3)                <\/span>\r\n    needInt(secondHouse);             \/\/ (3)<\/span>\r\n\t\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\t\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Now, instances of MyHouse<\/code> can be used when an int<\/code> is required. Strange! <\/p>\n
\"conversionOperator\"<\/p>\n
Due to the overloaded operator bool (2), instances of MyHouse<\/code> can be used as an int<\/code> and can, therefore, be used in arithmetic expressions: auto res = MyHouse() + 5<\/code>. This was not my intention! Just for completeness. With C++11, you can declare conversion operators as explicit<\/code>. Therefore implicit conversions are not allowed.<\/p>\n
My firm belief is that because of convenience reasons, we need the entire magic of conversions in C\/C++ to deal with the fact that functions only accept specific arguments.<\/strong><\/p>\n
Are templates the cure? No!<\/p>\n<\/p>\n
Too Generic<\/h3>\n
Generic functions or classes can be invoked with arbitrary values. If the values do not satisfy the requirements of the function or class, no problem. You will get a compile-time error. Fine!<\/p>\n
\n
\/\/ gcd.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/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>{\r\n    return<\/span> gcd(b, a %<\/span> b);\r\n  }\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> <\/span><\/span>gcd(100<\/span>, 10<\/span>)  <<<\/span> std::<\/span>endl;\r\n \r\n  std::<\/span>cout <<<\/span> gcd(3.5<\/span>, 4.0<\/span>)<<<\/span> std::<\/span>endl;\r\n  std::<\/span>cout <<<\/span> gcd(\"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
What is the problem with this error message?<\/p>\n
 \"genericGCD\"<\/p>\n
Of course, it is pretty long and quite challenging to understand, but my crucial concern is a different one. The compilation fails because neither double<\/code> or the C-strings supports the % operator. This means the error is due to the failed template instantiation for double <\/code>and C-string. This is too late and, therefore, really bad. No template instantiation for type double<\/code> or C-strings should be possible. The requirements for the arguments should be part of the function declaration and not a side-effect of an erroneous template instantiation.<\/p>\n
Now concepts come to our rescue.<\/p>\n
The Third Way<\/h3>\n
With concepts, we get something in between. We can define functions or classes that act on semantic categories with them. Meaning the arguments of functions or classes are either too specific or too generic but named sets of requirements such as Integral<\/code><\/em>.<\/p>\n
What’s next?<\/h2>\n
Sorry for this short post, but one week before my multithreading workshop at the CppCon, I had neither the time nor the resources (no connectivity in the national parks in Washington state) to write an entire post. My next post<\/a> will be particular because I will write about the CppCon. Afterward, I continue my story about generics and, in particular, about concepts.<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
Concepts revolutionize the way we think about and use generic programming. They didn’t make it in C++11 or C++17 but with C++20, we will get them with a high probability.<\/p>\n","protected":false},"author":21,"featured_media":5511,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[372],"tags":[415],"class_list":["post-5515","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-modern-c","tag-concepts"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5515","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=5515"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5515\/revisions"}],"predecessor-version":[{"id":6812,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5515\/revisions\/6812"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5511"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5515"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5515"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5515"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}