std::integral_constant
From cppreference.com
| Defined in header <type_traits>
|
||
template< class T, T v >
struct integral_constant;
|
(since C++11) | |
std::integral_constant wraps a static constant of specified type. It is the base class for the C++ type traits.
Helper templatesA helper alias template
|
(since C++17) |
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] |
static constant of type T with value v (public static member constant) |
Member functions
| returns the wrapped value (public member function) | |
(C++14) |
returns the wrapped value (public member function) |
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()
{
using two_t = std::integral_constant<int, 2>;
using four_t = std::integral_constant<int, 4>;
// static_assert(std::is_same<two_t, four_t>::value,
// "two_t and four_t are not equal!"); // error C2338: 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
};
using my_e_e1 = std::integral_constant<my_e, my_e::e1>;
using my_e_e2 = std::integral_constant<my_e, my_e::e2>;
// static_assert(my_e_e1::value == my_e::e2,
// "my_e_e1::value != my_e::e2"); //error C2338: my_e_e1::value!= my_e::e2
static_assert( ! std::is_same<my_e_e1, my_e_e2>::value,"my_e_e1 == my_e_e2");
// static_assert(std::is_same<my_e_e1, my_e_e2>::value,
// "my_e_e1 != my_e_e2"); // error C2338: my_e_e1!= my_e_e2
}