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 quebool(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.
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.
|
Plantilla de variable auxiliar
<tbody> </tbody> template<class... B> inline constexpr bool disjunction_v = disjunction<B...>::value; |
(desde C++17) | |
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...>> { };
|
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.
Ejemplo
#include <type_traits>
#include <string>
// comprobar si Foo es construible a partir de un double causará un error grave
struct 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 {
static constexpr bool 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<const char*>,
std::string>);
static_assert(std::is_same_v<first_constructible<std::string, int>::with<void*>, void>);
int main() { }
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) |