#include <iostream>
#include <type_traits>
int main(){
//creating an integral constant with constexpr
constexpr unsigned int speed_of_light{299792458};
//creating an integral constant with std::integral_constant
typedef std::integral_constant<unsigned int, 299792458> speed_of_light_2;
//using them
std::cout << speed_of_light/2 << '\n';
std::cout << speed_of_light_2::value/2 << '\n';
}
Ce qui est spécial sur std::integral_constant
que je choisirais de l'utiliser sur constexpr
?
[.____] Leur comportement et leurs cas d'utilisation semblent identiques à moi. J'essaie de penser à une sorte de scénario de modèle, où Constexpr peut ne pas suffire.
Modèle integral_constant
Définit un type, mot-clé constexpr
définit une constante. Par exemple std::true_type
est std::integral_constant<bool, true>
.
L'un des exemples d'utilisation est tag-dispatching
.
template<typename T>
void use_impl(const T&, std::false_type)
{
}
template<typename T>
void use_impl(const T&, std::true_type)
{
}
template<typename T>
void use(const T& v)
{
use_impl(v, typename std::is_integral<T>::type());
}
Il peut être utilisé avec l'opérateur ternaire, par exemple
void gotoN_impl(std::integral_constant<int,0>::type)
{
std::cout << "GoTo 0" << '\n';
}
void gotoN_impl(std::integral_constant<int,1>::type)
{
std::cout << "GoTo 1" << '\n';
}
void gotoN_impl(std::integral_constant<int,2>::type)
{
std::cout << "GoTo 2" << '\n';
}
void gotoN_impl(std::integral_constant<int,3>::type)
{
std::cout << "GoTo 3" << '\n';
}
template<int N>
void gotoN()
{
gotoN_impl(typename std::integral_constant<int, N>::type());
}
int main()
{
gotoN<0>();
gotoN<1>();
gotoN<2>();
gotoN<3>();
constexpr auto x = 99;
gotoN<x<4?x:3>(); // with a ternary operator
}