{"id":5614,"date":"2019-01-17T20:54:10","date_gmt":"2019-01-17T20:54:10","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-core-guidelines-programming-at-compile-time-with-the-type-traits\/"},"modified":"2023-06-26T10:15:56","modified_gmt":"2023-06-26T10:15:56","slug":"c-core-guidelines-programming-at-compile-time-with-the-type-traits","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-core-guidelines-programming-at-compile-time-with-the-type-traits\/","title":{"rendered":"C++ Core Guidelines: Programming at Compile Time with the Type-Traits"},"content":{"rendered":"

My journey through programming at compile time began in the last posts with template metaprogramming. Today, I jumped from C++98 to C++11. This is a jump to the type-traits library which is template metaprogramming in a standardized way.<\/p>\n

<\/p>\n

 \"TypeTraits\"<\/p>\n

The type-traits library<\/a> has been part of C++ since C++11. Its origin is in boost<\/a>. The type traits support type checks, comparisons, and type modifications at compile time. The library has over 100 functions, but each C++ standard adds new ones.<\/p>\n

I will not go into the details of the type-traits library because I have already written posts about it: type-traits library<\/a>. On the contrary, I cannot skip the type-traits library to continue my introduction to programming at compile time. In the end, here is my short introduction to the type-traits library. For more information, I add links to my older posts.<\/p>\n

First of all, what’s inside the type-traits library?<\/p>\n<\/p>\n

The Type-Traits Library<\/h2>\n

The library consists of type checks, type comparisons, and type modifications. Let me start with the type checks.<\/p>\n

Type Checks<\/h3>\n

Each type belongs precisely to one primary type category.<\/p>\n

Primary type categories<\/h4>\n

Here are they:<\/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_null_pointer;\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;



<\/pre>\n<\/div>\n
The following program gives you each primary type category a type.<\/p>\n
 <\/p>\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<\/span>(int<\/span>){return<\/span> 2011<\/span>;}\r\n};\r\n\r\nenum<\/span> E{\r\n  e=<\/span> 1<\/span>,\r\n};\r\n\r\nunion<\/span> U{\r\n  int<\/span> u;\r\n};\r\n\r\n\r\nint<\/span> main<\/span>(){\r\n  \r\n  std::<\/span>cout <<<\/span>  std::<\/span>boolalpha <<<\/span>  std::<\/span>endl;\r\n\r\n  std::<\/span>cout <<<\/span> std::<\/span>is_void<<\/span>void<\/span>>::<\/span>value <<<\/span> std::<\/span>endl;\r\n  std::<\/span>cout <<<\/span> std::<\/span>is_integral<<\/span>short<\/span>>::<\/span>value <<<\/span> std::<\/span>endl;\r\n  std::<\/span>cout <<<\/span> std::<\/span>is_floating_point<<\/span>double<\/span>>::<\/span>value <<<\/span> std::<\/span>endl;\r\n  std::<\/span>cout <<<\/span> std::<\/span>is_array<<\/span>int<\/span> []>::<\/span>value <<<\/span> std::<\/span>endl;\r\n  std::<\/span>cout <<<\/span> std::<\/span>is_pointer<<\/span>int<\/span>*>::<\/span>value <<<\/span> std::<\/span>endl;\r\n  std::<\/span>cout <<<\/span> std::<\/span>is_null_pointer<<\/span>std::nullptr_t<\/span>>::<\/span>value <<<\/span> std::<\/span>endl;\r\n  std::<\/span>cout <<<\/span> std::<\/span>is_member_object_pointer<<\/span>int<\/span> A::*>::<\/span>value <<<\/span>  std::<\/span>endl;\r\n  std::<\/span>cout <<<\/span> std::<\/span>is_member_function_pointer<<\/span>int<\/span> (A::*<\/span>)(int<\/span>)>::<\/span>value <<<\/span> std::<\/span>endl;\r\n  std::<\/span>cout <<<\/span> std::<\/span>is_enum<<\/span>E>::<\/span>value <<<\/span> std::<\/span>endl;\r\n  std::<\/span>cout <<<\/span> std::<\/span>is_union<<\/span>U>::<\/span>value <<<\/span> std::<\/span>endl;\r\n  std::<\/span>cout <<<\/span> std::<\/span>is_class<<\/span>std::<\/span>string>::<\/span>value <<<\/span> std::<\/span>endl;\r\n  std::<\/span>cout <<<\/span> std::<\/span>is_function<<\/span>int<\/span> *<\/span> (double<\/span>)>::<\/span>value <<<\/span> std::<\/span>endl;\t\r\n  std::<\/span>cout <<<\/span> std::<\/span>is_lvalue_reference<<\/span>int<\/span>&>::<\/span>value <<<\/span> std::<\/span>endl;\r\n  std::<\/span>cout <<<\/span> std::<\/span>is_rvalue_reference<<\/span>int<\/span>&&>::<\/span>value <<<\/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
Here is the output of the program:<\/p>\n
\"primaryTypeCategories\"<\/p>\n
If you want to know how this magic works, my post Check Types<\/a> provides more information.<\/p>\n
Based on the primary type categories are the composite type categories.<\/p>\n
Composite Type Categories<\/h4>\n
The following table shows the relation between the primary type categories and the composite type categories. <\/p>\n
 \"CompositeTypeCategories\"<\/p>\n
There are more type checks possible with the type traits.<\/p>\n
<\/p>\n
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_const;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_volatile;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivial;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivially_copyable;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_standard_layout;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_pod;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_literal_type;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_empty;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_polymorphic;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_abstract;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_signed;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_unsigned;
    template<\/span> <class<\/span> T<\/span>, class... Args> struct<\/span> is_constructible;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_default_constructible;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_copy_constructible;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_move_constructible;
    template<\/span> <class<\/span> T<\/span>, class<\/span> U<\/span>> struct<\/span> is_assignable;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_copy_assignable;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_move_assignable;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_destructible;
    template<\/span> <class<\/span> T<\/span>, class... Args> struct<\/span> is_trivially_constructible;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivially_default_constructible;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivially_copy_constructible;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivially_move_constructible;
    template<\/span> <class<\/span> T<\/span>, class<\/span> U<\/span>> struct<\/span> is_trivially_assignable;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivially_copy_assignable;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivially_move_assignable;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_trivially_destructible;
    template<\/span> <class<\/span> T<\/span>, class... Args> struct<\/span> is_nothrow_constructible;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_nothrow_default_constructible;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_nothrow_copy_constructible;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_nothrow_move_constructible;
    template<\/span> <class<\/span> T<\/span>, class<\/span> U<\/span>> struct<\/span> is_nothrow_assignable;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_nothrow_copy_assignable;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_nothrow_move_assignable;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> is_nothrow_destructible;
    template<\/span> <class<\/span> T<\/span>> struct<\/span> has_virtual_destructor;<\/pre>\n<\/div>\n
 <\/p>\n
Many of the function templates like is_trivially_copyable<\/span> have the name component trivially.<\/span> That means that these methods are not implemented by you but by the compiler.  Requesting a method from the compiler with the keyword default<\/span> is also trivial.<\/p>\n
Type Comparisons<\/h3>\n
The type-traits library supports three kinds of comparisons:<\/p>\n