std::disjunction - cppreference.com

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 Bi in B1, ..., BN para el que bool(Bi::value) == true, o BN si 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

Plantilla de variable auxiliar

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