![\"templatesTypeTraits\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/11\/templatesTypeTraits.png\")
<\/p>\nThe two main goals of the type-traits library are compelling: correctness and optimization. Today, I write about correctness.<\/p>\n
<\/p>\n
<\/p>\n
The type-traits library enables it to type queries, comparisons, and modifications at compile time. In my previous post about the type traits library, I only wrote about type queries and comparisons. Before I write about the correctness aspect of the type-traits library, I want to write a few words about type modifications.<\/p>\n
The type-traits library offers many metafunctions to manipulate types. Here are the most interesting ones.<\/p>\n
<\/p>\n
<\/p>\n
\/\/ const-volatile modifications:<\/span>\r\nremove_const;\r\nremove_volatile;\r\nremove_cv;\r\nadd_const;\r\nadd_volatile;\r\nadd_cv;\r\n\r\n\/\/ reference modifications:<\/span>\r\nremove_reference;\r\nadd_lvalue_reference;\r\nadd_rvalue_reference;\r\n\r\n\/\/ sign modifications:<\/span>\r\nmake_signed;\r\nmake_unsigned;\r\n\r\n\/\/ pointer modifications:<\/span>\r\nremove_pointer;\r\nadd_pointer;\r\n\r\n\/\/ other transformations:<\/span>\r\ndecay;\r\nenable_if;\r\nconditional;\r\ncommon_type;\r\nunderlying_type;\r\n<\/pre>\n<\/div>\n <\/p>\n
To get an int<\/code> from an int<\/code> or a const int<\/code>, you have to ask for the type with ::type<\/code>.<\/p>\n <\/p>\n
<\/p>\n
\nstd::<\/span>is_same<<\/span>int<\/span>, std::<\/span>remove_const<<\/span>int<\/span>>::<\/span>type>::<\/span>value; \/\/ true<\/span>\r\nstd::<\/span>is_same<<\/span>int<\/span>, std::<\/span>remove_const<<\/span>const<\/span> int<\/span>>::<\/span>type>::<\/span>value; \/\/ true<\/span>\r\n<\/pre>\n<\/div>\n <\/p>\n
Since C++14, you can use _t<\/code> to get the type, such as with std::remove_const_t<\/code>:<\/p>\n<\/p>\n
\nstd::<\/span>is_same<<\/span>int<\/span>, std::<\/span>remove_const_t<\/span><<\/span>int<\/span>>>::<\/span>value; \/\/ true<\/span>\r\nstd::<\/span>is_same<<\/span>int<\/span>, std::<\/span>remove_const_t<\/span><<\/span>const<\/span> int<\/span>>>::<\/span>value; \/\/ true<\/span>\r\n<\/pre>\n<\/div>\n <\/p>\n
To get an idea of how helpful these metafunctions from the type-traits library are, here are a few examples.<\/p>\n
\nstd::decay<\/code><\/strong>: std::thread<\/code> applies std::decay<\/code> to its arguments. The arguments of std::thread<\/code> , including the executed function f<\/code> and their arguments args<\/code>. Decay means that implicit conversions from array-to-pointer, function-to-pointer is performed, and const\/volatile<\/code> qualifiers and references are removed.<\/li>\nstd::enable_if<\/code><\/strong> is a convenient way to use SFINAE. SFINAE stands for Substitution Failure Is Not An Error and applies during overload resolution of a function template. If substituting the template parameter fails, the specialization is discarded from the overload set, but this failure causes no compiler error.<\/li>\nstd::conditional<\/code><\/strong> is the ternary operator at compile time?<\/li>\nstd::common_type<\/code><\/strong> determines the common type among all types to which all types can be converted.<\/li>\nstd::underlying_type<\/code><\/strong> determines the type of an enum.<\/li>\n<\/ul>\nMaybe, you are not convinced about the benefit of the type traits library. Let me end my series of posts to the type-traits library with its two main goals: correctness and optimization.<\/p>\n<\/p>\n
Correctness<\/h2>\n
Correctness means that you can use the type-traits library in C++11 to make your algorithm safer. The following implementation of the gcd algorithm requires that the binary modulo operator is valid for its arguments.<\/p>\n
<\/p>\n
\n\/\/ gcd2.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <type_traits><\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nT gcd(T a, T b) {\r\n static_assert(std::<\/span>is_integral<<\/span>T>::<\/span>value, \"T should be an integral type!\"<\/span>); \/\/ (1)<\/span>\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> gcd(100<\/span>, 33<\/span>) <<<\/span> '\\n'<\/span>;\r\n std::<\/span>cout <<<\/span> gcd(3.5<\/span>,4.0<\/span>) <<<\/span> '\\n'<\/span>;\r\n std::<\/span>cout <<<\/span> gcd(\"100\"<\/span>,\"10\"<\/span>) <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The error message is quite explicit.<\/p>\n
![\"gcd2\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/12\/gcd2.png\")
<\/p>\n
The compiler complains immediately that a double<\/code> or a const cha<\/code>r* is not an integral data type. Consequentially, the static_assert<\/code> expression in (1) fired<\/p>\nBut correctness means that you can use the type-traits libraries to implement concepts such as Integral<\/code>, SignedIntegral<\/code>, and UnsignedIntegral<\/code> in C++20.<\/p>\n<\/p>\n
\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nconcept Integral =<\/span> std::<\/span>is_integral<<\/span>T>::<\/span>value; \/\/ (1)<\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nconcept SignedIntegral =<\/span> Integral<<\/span>T><\/span> &&<\/span> std::<\/span>is_signed<<\/span>T>::<\/span>value; \/\/ (2)<\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nconcept UnsignedIntegral =<\/span> Integral<<\/span>T><\/span> &&<\/span> !<\/span>SignedIntegral<<\/span>T><\/span>;\r\n<\/pre>\n<\/div>\n <\/p>\n
The concept Integral<\/code> uses the type-traits functions directly std::is_integral<\/code> (1) and the concept SignedIntegral<\/code> the type-traits function std::is_signed<\/code> (2).<\/p>\nLet’s try it out and use the concept Integral<\/code> directly.<\/p>\n <\/p>\n
<\/p>\n
\n\/\/ gcdIntegral.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <type_traits><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nconcept Integral =<\/span> std::<\/span>is_integral<<\/span>T>::<\/span>value;\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nconcept SignedIntegral =<\/span> Integral<<\/span>T><\/span> &&<\/span> std::<\/span>is_signed<<\/span>T>::<\/span>value;\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nconcept UnsignedIntegral =<\/span> Integral<<\/span>T><\/span> &&<\/span> !<\/span>SignedIntegral<<\/span>T><\/span>;\r\n\r\nIntegral auto<\/span> gcd<\/span>(Integral auto<\/span> a, decltype(a) 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<\/span>() {\r\n\r\n std::<\/span>cout <<<\/span> gcd(100<\/span>, 33<\/span>) <<<\/span> '\\n'<\/span>;\r\n std::<\/span>cout <<<\/span> gcd(3.5<\/span>,4.0<\/span>) <<<\/span> '\\n'<\/span>;\r\n std::<\/span>cout <<<\/span> gcd(\"100\"<\/span>,\"10\"<\/span>) <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Now, the gcd algorithm is easier to read. It requires that the first argument a<\/code> and its return type are integral data types. To ensure that the second argument b<\/code> has the same type as the first type a <\/code>I specified its type as decltype(a)<\/code>. Consequentially, this implementation of the gcd<\/code> algorithm and the previous one in gcd2.cp<\/code>p are equivalent.<\/p>\nNow, the error message is more verbose such as the previous one.<\/p>\n
![\"gcdIntegral\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/12\/gcdIntegral.png\")
<\/p>\n
The error message of the GCC is not only too verbose but also too difficult to read. Let me try out Clang on the Compiler Explorer<\/a>. The error message about the erroneous usage of double reads like prose:<\/p>\n![\"gcdIntegralClang\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/12\/gcdIntegralClang.png\")
<\/p>\n
I don’t think an error message could be easier to read.<\/p>\n
Finally, I wanted to try out the latest Microsoft Visual Studio Compiler. This compiler supports concepts with one exception: the so-called abbreviated function template syntax. You may already guess it. I used the abbreviated function template syntax in my gcd algorithm. You can read more about this nice syntax in my previous post: C++20: Concepts – Syntactic Sugar<\/a>.<\/p>\nWhat’s next?<\/h2>\n
Of course, you know what I will write about in my next post: the performance story of the type-traits library.<\/p>\n
<\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
The two main goals of the type-traits library are compelling: correctness and optimization. Today, I write about correctness.<\/p>\n","protected":false},"author":21,"featured_media":6251,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[376],"tags":[419],"class_list":["post-6261","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-templates","tag-type-traits"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6261","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=6261"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6261\/revisions"}],"predecessor-version":[{"id":6688,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6261\/revisions\/6688"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6251"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6261"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6261"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6261"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}