std::integral_constant - cppreference.com

De cppreference.com


`template< class T, T v > struct integral_constant;`		(desde C++11)

std::integral_constant envuelve una constante estática del tipo especificado. Es la clase base para los rasgos de tipo de C++.

El comportamiento de un programa que añade especializaciones para integral_constant no está definido.

Plantillas auxiliares

Se define un alias de plantilla auxiliar std::bool_constant para el caso común donde T es bool.

`template <bool B> using bool_constant = integral_constant<bool, B>;`		(desde C++17)

Especializaciones

Se proporcionan dos declaraciones typedef para el caso común donde T es bool:


Tipo	Definición
`true_type`	`std::integral_constant<bool, true>`
`false_type`	`std::integral_constant<bool, false>`

Tipos miembro

Tipo	Definición
`value_type`	`T`
`type`	`std::integral_constant<T, v>`

Constantes miembro

Nombre	Valor
	`v` (constante miembro pública estática)

Funciones miembro

std::integral_constant::operator value_type

`constexpr operator value_type() const noexcept;`

Función de conversión. Devuelve el valor envuelto.

std::integral_constant::operator()

`constexpr value_type operator()() const noexcept;`		(desde C++14)

Devuelve el valor envuelto. Esta función habilita a std::integral_constant para que sirva como fuente de objetos función en tiempo de compilación.

Posible implementación

template<class T, T v>
struct integral_constant
{
    static constexpr T value = v;
    using value_type = T;
    using type = integral_constant; // usando el nombre de clase inyectado
    constexpr operator value_type() const noexcept { return value; }
    constexpr value_type operator()() const noexcept { return value; } // desde c++14
};

Notas

Macro de prueba de característica	Valor	Estándar	Comentario
`__cpp_lib_integral_constant_callable`	`201304L`	(C++14)	`std::integral_constant::operator()`
`__cpp_lib_bool_constant`	`201505L`	(C++17)	`std::bool_constant`

Ejemplo

#include <type_traits>

using two_t = std::integral_constant<int, 2>;
using four_t = std::integral_constant<int, 4>;

static_assert(not std::is_same_v<two_t, four_t>);
static_assert(two_t::value * 2 == four_t::value, "2*2 != 4");
static_assert(two_t() << 1 == four_t() >> 0, "2*2 != 4");

enum class E{ e1, e2 };
using c1 = std::integral_constant<E, E::e1>;
using c2 = std::integral_constant<E, E::e2>;
static_assert(c1::value != E::e2);
static_assert(c1() == E::e1);
static_assert(std::is_same_v<c2, c2>);

int main() {}