type_traits

---

1. Check if a type is signed:

#include <type_traits>

template <typename T>
struct is_signed : std::integral_constant<bool, std::is_signed<T>::value> {};

static_assert(is_signed<int>::value);
static_assert(!is_signed<unsigned int>::value);

1. Check if a type is floating-point:

#include <type_traits>

template <typename T>
struct is_floating_point : std::integral_constant<bool, std::is_floating_point<T>::value> {};

static_assert(is_floating_point<float>::value);
static_assert(!is_floating_point<int>::value);

1. Check if a type is a fundamental type:

#include <type_traits>

template <typename T>
struct is_fundamental : std::integral_constant<bool, std::is_fundamental<T>::value> {};

static_assert(is_fundamental<int>::value);
static_assert(!is_fundamental<std::string>::value);

1. Check if a type is a pointer:

#include <type_traits>

template <typename T>
struct is_pointer : std::integral_constant<bool, std::is_pointer<T>::value> {};

static_assert(is_pointer<int*>::value);
static_assert(!is_pointer<int>::value);

1. Check if a type is a reference:

#include <type_traits>

template <typename T>
struct is_reference : std::integral_constant<bool, std::is_reference<T>::value> {};

static_assert(is_reference<int&>::value);
static_assert(!is_reference<int>::value);

1. Check if a type is an array:

#include <type_traits>

template <typename T>
struct is_array : std::integral_constant<bool, std::is_array<T>::value> {};

static_assert(is_array<int[10]>::value);
static_assert(!is_array<int>::value);

1. Check if a type is a function:

#include <type_traits>

template <typename T>
struct is_function : std::integral_constant<bool, std::is_function<T>::value> {};

static_assert(is_function<int(int)>::value);
static_assert(!is_function<int>::value);

1. Check if a type is a class:

#include <type_traits>

template <typename T>
struct is_class : std::integral_constant<bool, std::is_class<T>::value> {};

static_assert(is_class<std::string>::value);
static_assert(!is_class<int>::value);

1. Check if a type is a structure:

#include <type_traits>

template <typename T>
struct is_struct : std::integral_constant<bool, std::is_struct<T>::value> {};

static_assert(is_struct<std::pair<int, int>>::value);
static_assert(!is_struct<int>::value);

1. Check if a type is an enumeration:

#include <type_traits>

template <typename T>
struct is_enum : std::integral_constant<bool, std::is_enum<T>::value> {};

static_assert(is_enum<enum class Color { Red, Green, Blue }>::value);
static_assert(!is_enum<int>::value);

1. Check if a type is a union:

#include <type_traits>

template <typename T>
struct is_union : std::integral_constant<bool, std::is_union<T>::value> {};

static_assert(is_union<union { int a; float b; }>::value);
static_assert(!is_union<int>::value);

1. Get the size of a type in bytes:

#include <type_traits>

template <typename T>
struct type_size : std::integral_constant<size_t, sizeof(T)> {};

static_assert(type_size<int>::value == 4);

1. Get the alignment of a type in bytes:

#include <type_traits>

template <typename T>
struct type_alignment : std::integral_constant<size_t, alignof(T)> {};

static_assert(type_alignment<int>::value == 4);

1. Check if a type is a const-qualified type:

#include <type_traits>

template <typename T>
struct is_const : std::integral_constant<bool, std::is_const<T>::value> {};

static_assert(is_const<const int>::value);
static_assert(!is_const<int>::value);

1. Check if a type is a volatile-qualified type:

#include <type_traits>

template <typename T>
struct is_volatile : std::integral_constant<bool, std::is_volatile<T>::value> {};

static_assert(is_volatile<volatile int>::value);
static_assert(!is_volatile<int>::value);

1. Check if a type is a const-volatile-qualified type:

#include <type_traits>

template <typename T>
struct is_const_volatile : std::integral_constant<bool, std::is_const_volatile<T>::value> {};

static_assert(is_const_volatile<const volatile int>::value);
static_assert(!is_const_volatile<int>::value);

1. Get the underlying type of a pointer or reference type:

#include <type_traits>

template <typename T>
struct underlying_type : std::remove_reference<std::remove