std:: conjunction

Bildet die logische Konjunktion der Typ-Merkmale B... , was effektiv eine logische UND-Verknüpfung der Merkmalssequenz durchführt.

Die Spezialisierung std :: conjunction < B1, ..., BN > hat eine öffentliche und eindeutige Basis, die

• wenn sizeof... ( B ) == 0 , std:: true_type ; andernfalls
• der erste Typ Bi in B1, ..., BN für den bool ( Bi :: value ) == false , oder BN falls kein solcher Typ existiert.

Die Member-Namen der Basisklasse, außer conjunction und operator= , werden nicht verborgen und sind in conjunction eindeutig verfügbar.

Konjunktion ist kurzschließend: wenn es ein Template-Typenargument Bi gibt mit bool ( Bi :: value ) == false , dann erfordert die Instanziierung von conjunction < B1, ..., BN > :: value nicht die Instanziierung von Bj :: value für j > i .

Wenn das Programm Spezialisierungen für std::conjunction oder std::conjunction_v hinzufügt, ist das Verhalten undefiniert.

Template-Parameter

Hilfsvariablen-Template

Mögliche Implementierung

template<class...>
struct conjunction : std::true_type {};
template<class B1>
struct conjunction<B1> : B1 {};
template<class B1, class... Bn>
struct conjunction<B1, Bn...>
    : std::conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};

Hinweise

Eine Spezialisierung von conjunction erbt nicht notwendigerweise von entweder std:: true_type oder std:: false_type : Sie erbt einfach vom ersten B , dessen ::value , explizit konvertiert zu bool , false ist, oder vom letzten B , wenn alle zu true konvertieren. Zum Beispiel ist std :: conjunction < std:: integral_constant < int , 2 > , std:: integral_constant < int , 4 >> :: value gleich 4 .

Die Kurzschluss-Instanziierung unterscheidet conjunction von Fold-Ausdrücken : Ein Fold-Ausdruck, wie ( ... && Bs :: value ) , instanziiert jedes B in Bs , während std :: conjunction_v < Bs... > die Instanziierung stoppt, sobald der Wert bestimmt werden kann. Dies ist besonders nützlich, wenn der spätere Typ aufwändig zu instanziieren ist oder einen schwerwiegenden Fehler verursachen kann, wenn er mit dem falschen Typ instanziiert wird.

Beispiel

#include <iostream>
#include <type_traits>
// func ist aktiviert, wenn alle Ts... denselben Typ wie T haben
template<typename T, typename... Ts>
std::enable_if_t<std::conjunction_v<std::is_same<T, Ts>...>>
func(T, Ts...)
{
    std::cout << "All types in pack are the same.\n";
}
// andernfalls
template<typename T, typename... Ts>
std::enable_if_t<!std::conjunction_v<std::is_same<T, Ts>...>>
func(T, Ts...)
{
    std::cout << "Not all types in pack are the same.\n";
}
template<typename T, typename... Ts>
constexpr bool all_types_are_same = std::conjunction_v<std::is_same<T, Ts>...>;
static_assert(all_types_are_same<int, int, int>);
static_assert(not all_types_are_same<int, int&, int>);
int main()
{
    func(1, 2, 3);
    func(1, 2, "hello!");
}

All types in pack are the same.
Not all types in pack are the same.

Siehe auch