std::disjunction
Definido en el archivo de encabezado <type_traits> | ||
template<class... B> struct disjunction; | (desde C++17) | |
Forma la disyunción lógica de los rasgos de tipo B..., efectivamente llevando a cabo un OR lógico en la secuencia de rasgos.
La especialización std::disjunction<B1, ..., BN> tiene una base pública e inequívoca que es
- si sizeof...(B)==0, std::false_type; de lo contrario,
- el primer tipo
BiinB1, ..., BNpara el que bool(Bi::value)==true, oBNsi no existe tal tipo.
Los nombres de los miembros de la clase base, excepto disjunction y operator=, no están ocultos y están inequivocadamente disponibles en disjunction.
La conjunción es de cortocircuito: si hay un argumento de plantilla de tipo Bi con bool(Bi::value)!=false, entonces instanciar disjunction<B1, ..., BN>::value no requiere la instanciación de Bj::value para j > i.
El comportamiento de un programa que añade especializaciones para disjunction o disjunction_v no está definido.
Contenido |
[editar]Parámetros de plantilla
| B... | - | Todo argumento de plantilla Bi para el que Bi::value se instancia debe ser utilizable como una clase base y definir el miembro value, que es convertible a bool. |
[editar]Plantilla de variable auxiliar
template<class... B> inlineconstexprbool disjunction_v = disjunction<B...>::value; | (desde C++17) | |
[editar]Posible implementación
template<class...>struct disjunction :std::false_type{};template<class B1>struct disjunction<B1>: B1 {};template<class B1, class... Bn>struct disjunction<B1, Bn...>:std::conditional_t<bool(B1::value), B1, disjunction<Bn...>>{}; |
[editar]Notas
Una especialización de disjunction no necesariamente hereda de std::true_type o de std::false_type: simplemente hereda de la primera B cuyo miembro ::value, explícitamente convertido a bool, es true, o de la última B cuando todos pueden convertirse a. Por ejemplo, std::disjunction<std::integral_constant<int, 2>, std::integral_constant<int, 4>>::value es 2.
La instanciación de cortocircuito diferencia a disjunction de las expresiones de pliegue: una expresión de pliegue como (... || Bs::value) instancia toda B en Bs, mientras que std::disjunction_v<Bs...> detiene la instanciación una vez que el valor puede determinarse. Esto es particularmente útil si el tipo posterior es costoso de instanciar o puede causar un error grave cuando se instancia con el tipo incorrecto.
[editar]Ejemplo
#include <type_traits>#include <string> // comprobar si Foo es construible a partir de un double causará un error gravestruct Foo {template<class T>struct sfinae_unfriendly_check { static_assert(!std::is_same_v<T, double>);}; template<class T> Foo(T, sfinae_unfriendly_check<T>={});}; template<class... Ts>struct first_constructible {template<class T, class...Args>struct is_constructible_x :std::is_constructible<T, Args...>{using type = T;};struct fallback {staticconstexprbool value =true;using type =void;// tipo a devolver si no se encuentra nada}; template<class... Args>using with =typename std::disjunction<is_constructible_x<Ts, Args...>..., fallback>::type;}; // de acuerdo, no se instancia is_constructible<Foo, double> static_assert(std::is_same_v<first_constructible<std::string, int, Foo>::with<double>, int>); static_assert(std::is_same_v<first_constructible<std::string, int>::with<>, std::string>); static_assert(std::is_same_v<first_constructible<std::string, int>::with<constchar*>, std::string>); static_assert(std::is_same_v<first_constructible<std::string, int>::with<void*>, void>); int main(){}
[editar]Véase también
(C++17) | Metafunción NOT lógico. (plantilla de clase) |
(C++17) | Metafunción variádica de AND lógico. (plantilla de clase) |
