{"id":4989,"date":"2016-10-18T06:14:32","date_gmt":"2016-10-18T06:14:32","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/check-types\/"},"modified":"2023-06-26T12:38:55","modified_gmt":"2023-06-26T12:38:55","slug":"check-types","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/check-types\/","title":{"rendered":"Check Types"},"content":{"rendered":"

Template Metaprogramming is programming at compile time. But what has template metaprogramming in common with the type-traits library? A lot! The type-traits library is pure template metaprogramming, tamed in a library. With this post, my presentation of the type-traits library becomes more structured.<\/p>\n

<\/p>\n

Check type properties<\/h2>\n

The type-trait library supports primary and composite type categories. You get the answer with the attribute value<\/span>. <\/p>\n

Primary type categories<\/h3>\n

C++ has 14 primary type categories. They are complete and orthogonal. This means that each type is exactly a member of one type category. The check for the type categories is independent of the type qualifiers const<\/span> or volatile<\/span>.  <\/p>\n

The 14 primary type categories:<\/p>\n

<\/p>\n

\n
template<\/span> <class<\/span> T<\/span>> struct<\/span> is_void;\r\ntemplate<\/span> <class<\/span> T<\/span>> struct<\/span> is_integral;\r\ntemplate<\/span> <class<\/span> T<\/span>> struct<\/span> is_floating_point;\r\ntemplate<\/span> <class<\/span> T<\/span>> struct<\/span> is_array;\r\ntemplate<\/span> <class<\/span> T<\/span>> struct<\/span> is_pointer;\r\ntemplate<\/span> <class<\/span> T<\/span>> struct<\/span> is_reference;\r\ntemplate<\/span> <class<\/span> T<\/span>> struct<\/span> is_member_object_pointer;\r\ntemplate<\/span> <class<\/span> T<\/span>> struct<\/span> is_member_function_pointer;\r\ntemplate<\/span> <class<\/span> T<\/span>> struct<\/span> is_enum;\r\ntemplate<\/span> <class<\/span> T<\/span>> struct<\/span> is_union;\r\ntemplate<\/span> <class<\/span> T<\/span>> struct<\/span> is_class;\r\ntemplate<\/span> <class<\/span> T<\/span>> struct<\/span> is_function;\r\ntemplate<\/span> <class<\/span> T<\/span>> struct<\/span> is_lvalue_reference;\r\ntemplate<\/span> <class<\/span> T<\/span>> struct<\/span> is_rvalue_reference;\r\n<\/pre>\n<\/div>\n
 <\/p>\n
And here is the application of the primary type categories:<\/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<\/pre>\n<\/td>\n
\n
\/\/  primaryTypeCategories.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <type_traits><\/span>\r\n\r\nstruct<\/span> A{\r\n  int<\/span> a;\r\n  int<\/span> f(int<\/span>){return<\/span> 2011;}\r\n};\r\n\r\nenum<\/span> E{\r\n  e= 1,\r\n};\r\n\r\nunion<\/span> U{\r\n  int<\/span> u;\r\n};\r\n\r\n\r\nint<\/span> main(){\r\n  \r\n  std::cout <<  std::boolalpha <<  std::endl;\r\n\r\n  std::cout << std::is_void<void<\/span>>::value << std::endl;\r\n  std::cout << std::is_integral<short<\/span>>::value << std::endl;\r\n  std::cout << std::is_floating_point<double<\/span>>::value << std::endl;\r\n  std::cout << std::is_array<int<\/span> [] >::value << std::endl;\r\n  std::cout << std::is_pointer<int<\/span>*>::value << std::endl;\r\n  std::cout << std::is_reference<int<\/span>&>::value << std::endl;\r\n  std::cout << std::is_member_object_pointer<int<\/span> A::*>::value <<  std::endl;\r\n  std::cout << std::is_member_function_pointer<int<\/span> (A::*)(int<\/span>)>::value << std::endl;\r\n  std::cout << std::is_enum<E>::value << std::endl;\r\n  std::cout << std::is_union<U>::value << std::endl;\r\n  std::cout << std::is_class<std::string>::value << std::endl;\r\n  std::cout << std::is_function<int<\/span> * (double<\/span>)>::value << std::endl;\t\r\n  std::cout << std::is_lvalue_reference<int<\/span>&>::value << std::endl;\r\n  std::cout << std::is_rvalue_reference<int<\/span>&&>::value << std::endl;\r\n  \r\n  std::cout <<  std::endl;\r\n\r\n}\t\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/span><\/span><\/p>\n
Thanks to the use of the flag std::boolalpha<\/span> in line 22, the program displays true<\/span> or false <\/span>instead of 1 or 0. Each call of the 14 primary type categories returns true.<\/p>\n
\"primaryTypeCategories\"<\/p>\n
How does the magic work?<\/h3>\n
The technique’s key is based on templates and template specialization, a few conventions, and a lot of typing. I wrote a possible implementation of the function template std::integral. std::integra<\/span>l will check if the type is integral.<\/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\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56\r\n57\r\n58\r\n59\r\n60\r\n61\r\n62\r\n63\r\n64\r\n65\r\n66\r\n67\r\n68\r\n69\r\n70\r\n71\r\n72\r\n73\r\n74\r\n75\r\n76\r\n77\r\n78\r\n79\r\n80\r\n81\r\n82\r\n83\r\n84\r\n85\r\n86\r\n87\r\n88\r\n89\r\n90\r\n91\r\n92<\/pre>\n<\/td>\n
\n
\/\/ integral.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <type_traits><\/span>\r\n\r\nnamespace<\/span> rgr{\r\n\r\n  template<\/span><class<\/span> T<\/span>, T v>\r\n  struct<\/span> integral_constant {\r\n      static<\/span> constexpr T value = v;\r\n      typedef<\/span> T value_type;\r\n      typedef<\/span> integral_constant type;\r\n      constexpr operator<\/span> value_type() const<\/span> noexcept { return<\/span> value; }\r\n      constexpr value_type operator<\/span>()() const<\/span> noexcept { return<\/span> value; } \/\/since c++14<\/span>\r\n  };\r\n\r\n  typedef<\/span> integral_constant<bool<\/span>, true> true_type;\r\n  typedef<\/span> integral_constant<bool<\/span>, false> false_type;\r\n\r\n  template<\/span> <class<\/span> T<\/span>>\r\n  struct<\/span> is_integral : public<\/span> false_type{};\r\n\r\n  template<\/span> <>\r\n  struct<\/span> is_integral<bool<\/span>> : public<\/span> true_type{};\r\n\r\n  template<\/span> <>\r\n  struct<\/span> is_integral<char<\/span>> : public<\/span> true_type{};\r\n\r\n  template<\/span> <>\r\n  struct<\/span> is_integral<signed<\/span> char<\/span>> : public<\/span> true_type{};\r\n\r\n  template<\/span> <>\r\n  struct<\/span> is_integral<unsigned<\/span> char<\/span>> : public<\/span> true_type{};\r\n\r\n  template<\/span> <>\r\n  struct<\/span> is_integral<wchar_t<\/span>> : public<\/span> true_type{};\r\n\r\n  template<\/span> <>\r\n  struct<\/span> is_integral<short<\/span>> : public<\/span> true_type{};\r\n\r\n  template<\/span> <>\r\n  struct<\/span> is_integral<int<\/span>> : public<\/span> true_type{};\r\n\r\n  template<\/span> <>\r\n  struct<\/span> is_integral<long<\/span>> : public<\/span> true_type{};\r\n\r\n  template<\/span> <>\r\n  struct<\/span> is_integral<long<\/span> long<\/span>> : public<\/span> true_type{};\r\n\r\n  template<\/span> <>\r\n  struct<\/span> is_integral<unsigned<\/span> short<\/span>> : public<\/span> true_type{};\r\n\r\n  template<\/span> <>\r\n  struct<\/span> is_integral<unsigned<\/span> int<\/span>> : public<\/span> true_type{};\r\n\r\n  template<\/span> <>\r\n  struct<\/span> is_integral<unsigned<\/span> long<\/span>> : public<\/span> true_type{};\r\n\r\n  template<\/span> <>\r\n  struct<\/span> is_integral<unsigned<\/span> long<\/span> long<\/span>> : public<\/span> true_type{};\r\n  \r\n}\r\n\r\nint<\/span> main(){\r\n  \r\n  std::cout << std::boolalpha << std::endl;\r\n  \r\n  std::cout << \"std::is_integral<int>::value: \"<\/span> << std::is_integral<int<\/span>>::value << std::endl;\r\n  std::cout << \"rgr::is_integral<int>::value: \"<\/span> << rgr::is_integral<int<\/span>>::value << std::endl;\r\n  \r\n  std::cout << \"std::is_integral<double>::value: \"<\/span> << std::is_integral<double<\/span>>::value << std::endl;\r\n  std::cout << \"rgr::is_integral<double>::value: \"<\/span> << rgr::is_integral<double<\/span>>::value << std::endl;\r\n  \r\n  std::cout << std::endl;\r\n  \r\n  std::cout << \"std::true_type::value: \"<\/span> << std::true_type::value << std::endl;\r\n  std::cout << \"rgr::true_type::value: \"<\/span> << rgr::true_type::value << std::endl;\r\n  \r\n  std::cout << \"std::false_type::value: \"<\/span> << std::false_type::value << std::endl;\r\n  std::cout << \"rgr::false_type::value: \"<\/span> << rgr::false_type::value << std::endl;\r\n  \r\n  std::cout << std::endl;\r\n  \r\n  std::cout << \"std::integral_constant<bool, true>::value: \"<\/span> << std::integral_constant<bool<\/span>, true>::value << std::endl;\r\n  std::cout << \"rgr::integral_constant<bool, true>::value: \"<\/span> << rgr::integral_constant<bool<\/span>, true>::value << std::endl;\r\n  \r\n  std::cout << \"std::integral_constant<bool, false>::value: \"<\/span> << std::integral_constant<bool<\/span>, false>::value << std::endl;\r\n  std::cout << \"rgr::integral_constant<bool, false>::value: \"<\/span> << rgr::integral_constant<bool<\/span>, false>::value << 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
I use in my implementation the namespace rgr<\/span> and compare my implementation with type-traits implementation in the namespace std<\/span>. The invocation of the function template rgr::is_integral<int>::value (line 69) causes under the hood the invocation of the expression <\/span><\/span>rgr::true_type::value (line 77) because <\/span>integral<int> is derived from<\/span> true_type (line 42)<\/span>. rgr::true_type::value is an alias for<\/span> rgr::integral_constant<bool, true>::value <\/span> <\/span> <\/span>(line 17). I use only in the example the static constexpr<\/span> value<\/span> of the class integral_constant. integral_constant<\/span> is the base class of the type-traits functions. <\/span>
<\/span> <\/span> <\/span> <\/span><\/p>\n
For completeness, the output of the program. My implementation behaves like the type-traits library.<\/p>\n
 \"integral\"<\/p>\n
Based on the 14 primary type categories, there are seven composite type categories in C++.<\/p>\n<\/p>\n
Composite type categories<\/h3>\n
 
\"CompositeTypeCategories\"<\/p>\n
The is_fundamental<\/span> type category uses the function template is_same.<\/span> More about I in the next post, in which I will write about type comparisons with the type-traits library.<\/p>\n
There are more type checks possible with the type-traits.<\/p>\n
Type properties<\/h3>\n
In addition to the primary and composite type categories, you can check the type properties. <\/p>\n
<\/p>\n
\n
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_const;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_volatile;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivial;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivially_copyable;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_standard_layout;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_pod;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_literal_type;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_empty;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_polymorphic;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_abstract;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_signed;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_unsigned;\r\n    template<\/span> <class<\/span> T<\/span>, class... Args> struct<\/span> is_constructible;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_default_constructible;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_copy_constructible;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_move_constructible;\r\n    template<\/span> <class<\/span> T<\/span>, class<\/span> U<\/span>> struct<\/span> is_assignable;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_copy_assignable;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_move_assignable;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_destructible;\r\n    template<\/span> <class<\/span> T<\/span>, class... Args> struct<\/span> is_trivially_constructible;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivially_default_constructible;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivially_copy_constructible;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivially_move_constructible;\r\n    template<\/span> <class<\/span> T<\/span>, class<\/span> U<\/span>> struct<\/span> is_trivially_assignable;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivially_copy_assignable;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivially_move_assignable;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivially_destructible;\r\n    template<\/span> <class<\/span> T<\/span>, class... Args> struct<\/span> is_nothrow_constructible;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_nothrow_default_constructible;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_nothrow_copy_constructible;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_nothrow_move_constructible;\r\n    template<\/span> <class<\/span> T<\/span>, class<\/span> U<\/span>> struct<\/span> is_nothrow_assignable;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_nothrow_copy_assignable;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_nothrow_move_assignable;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_nothrow_destructible;\r\n    template<\/span> <class<\/span> T<\/span>> struct<\/span> has_virtual_destructor;\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Many of the function templates like is_trivially_copyable, have the name component trivially. That means these methods must be generated by the compiler and not by the developer. A method you explicitly request from the compiler with the keyword default<\/span> is also trivial.<\/p>\n
 <\/p>\n
What’s next?<\/h2>\n
The type-traits library has a lot to offer. I will write in the next post<\/a> about type comparison and type modifications at compile time.<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n<\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
Template Metaprogramming is programming at compile time. But what has template metaprogramming in common with the type-traits library? A lot! The type-traits library is pure template metaprogramming, tamed in a library. With this post, my presentation of the type-traits library becomes more structured.<\/p>\n","protected":false},"author":21,"featured_media":4986,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[364],"tags":[419],"class_list":["post-4989","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-embedded","tag-type-traits"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4989","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=4989"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4989\/revisions"}],"predecessor-version":[{"id":6935,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4989\/revisions\/6935"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/4986"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=4989"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=4989"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=4989"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}