std::integral_constant (3) - Linux Manuals

std::integral_constant: std::integral_constant

NAME

std::integral_constant - std::integral_constant

Synopsis

Defined in header <type_traits>
template< class T, T v > (since C++11)
struct integral_constant;

std::integral_constant wraps a static constant of specified type. It is the base class for the C++ type traits.

Helper templates

A helper alias template std::bool_constant is defined for the common case where T is bool. (since C++17)

template <bool B>
using bool_constant = integral_constant<bool, B>;

Two typedefs for the common case where T is bool are provided:

Defined in header <type_traits>
Type Definition
true_type std::integral_constant<bool, true>
false_type std::integral_constant<bool, false>

Member types

Type Definition
value_type T
type std::integral_constant<T,v>

Member constants

Name Value

constexpr T value static constant of type T with value v
                  (public static member constant)
[static]

Member functions

                    returns the wrapped value
operator value_type (public member function)

operator() returns the wrapped value
                    (public member function)
(C++14)

 std::integral_constant::operator value_type

constexpr operator value_type() const noexcept;

Conversion function. Returns the wrapped value.

 std::integral_constant::operator()

constexpr value_type operator()() const noexcept; (since C++14)

Returns the wrapped value. This function enables std::integral_constant to serve as a source of compile-time function objects.

Possible implementation

  template<class T, T v>
  struct integral_constant {
      static constexpr T value = v;
      typedef T value_type;
      typedef integral_constant type; // using injected-class-name
      constexpr operator value_type() const noexcept { return value; }
      constexpr value_type operator()() const noexcept { return value; } //since c++14
  };

Example

// Run this code

  #include <iostream>
  #include <type_traits>

  int main()
  {
      typedef std::integral_constant<int, 2> two_t;
      typedef std::integral_constant<int, 4> four_t;

  // static_assert(std::is_same<two_t, four_t>::value,
  // "two_t and four_t are not equal!");
  // error: static assertion failed: "two_t and four_t are not equal!"

      static_assert(two_t::value*2 == four_t::value,
         "2*2 != 4"
      );

      enum class my_e {
         e1,
         e2
      };
      typedef std::integral_constant<my_e, my_e::e1> my_e_e1;
      typedef std::integral_constant<my_e, my_e::e2> my_e_e2;

  // static_assert(my_e_e1::value == my_e::e2,
  // "my_e_e1::value != my_e::e2");
  // error: static assertion failed: "my_e_e1::value != my_e::e2"

      static_assert(std::is_same<my_e_e2, my_e_e2>::value,
                    "my_e_e2 != my_e_e2");
  }