<type_traits> -Funktionen

is_assignable
is_copy_assignable
is_copy_constructible
is_default_constructible
is_move_assignable
is_move_constructible
is_nothrow_move_assignable
is_nothrow_swappable
is_nothrow_swappable_with
is_swappable
is_swappable_with
is_trivially_copy_assignable
is_trivially_move_assignable
is_trivially_move_constructible

is_assignable

Überprüft, ob einem Typ "An" ein Wert vom Typ "Von" zugewiesen werden kann.

template <class To, class From>
struct is_assignable;

Parameter

An
Der Typ des Objekts, das die Zuweisung empfängt.

Von
Der Typ des Objekts, das den Wert bereitstellt.

Hinweise

Der ausgewertete Ausdruck declval<To>() = declval<From>() muss wohlgeformt sein. "Von" und "An" müssen vollständige Typen voidoder Arrays unbekannter Grenzen sein.

is_copy_assignable

Testet, ob der Typ durch Zuweisung kopiert werden kann.

template <class Ty>
struct is_copy_assignable;

Parameter

Ty
Der abzufragende Typ.

Hinweise

Eine Instanz des Typprädikats enthält "true", wenn der Typ "Ty" eine Klasse ist, die über einen Kopierzuweisungsoperator verfügt, andernfalls "false". Entspricht is_assignable<Ty&, const Ty&>.

is_copy_constructible

Testet, ob der Typ einen Kopierkonstruktor aufweist.

template <class Ty>
struct is_copy_constructible;

Parameter

Ty
Der abzufragende Typ.

Hinweise

Eine Instanz des Typprädikats enthält "true", wenn der Typ "Ty" eine Klasse mit einem Kopierkonstruktor ist, andernfalls "false".

Beispiel

#include <type_traits>
#include <iostream>

struct Copyable
{
    int val;
};

struct NotCopyable
{
   NotCopyable(const NotCopyable&) = delete;
   int val;

};

int main()
{
    std::cout << "is_copy_constructible<Copyable> == " << std::boolalpha
        << std::is_copy_constructible<Copyable>::value << std::endl;
    std::cout << "is_copy_constructible<NotCopyable> == " << std::boolalpha
        << std::is_copy_constructible<NotCopyable>::value << std::endl;

    return (0);
}

is_copy_constructible<Copyable> == true
is_copy_constructible<NotCopyable > == false

is_default_constructible

Testet, ob ein Typ einen Standardkonstruktor besitzt.

template <class Ty>
struct is_default_constructible;

Parameter

T
Der abzufragende Typ.

Hinweise

Eine Instanz des Typprädikats enthält "true", wenn der Typ T ein Klassentyp ist, der über einen Standardkonstruktor verfügt, andernfalls "false". Dies entspricht dem Prädikat is_constructible<T>. Typ T muss ein vollständiger Typ oder voidein Array unbekannter Gebundenes sein.

Beispiel

#include <type_traits>
#include <iostream>

struct Simple
{
    Simple() : val(0) {}
    int val;
};

struct Simple2
{
    Simple2(int v) : val(v) {}
    int val;
};

int main()
{
    std::cout << "is_default_constructible<Simple> == " << std::boolalpha
        << std::is_default_constructible<Simple>::value << std::endl;
    std::cout << "is_default_constructible<Simple2> == " << std::boolalpha
        << std::is_default_constructible<Simple2>::value << std::endl;

    return (0);
}

is_default_constructible<Simple> == true
is_default_constructible<Simple2> == false

is_move_assignable

Prüft, ob dem Typ eine Verschiebung zugewiesen werden kann.

template <class T>
struct is_move_assignable;

Parameter

T
Der abzufragende Typ.

Hinweise

Einem Typ kann eine Verschiebung zugewiesen werden, wenn ein rvalue-Verweis auf den Typ einem Verweis auf den Typ zugewiesen werden kann. Das Typprädikat entspricht is_assignable<T&, T&&>. Zu den Typen, denen eine Verschiebung zugewiesen werden kann, gehören verweisbare skalare Typen und Klassentypen, die entweder über vom Compiler generierte oder benutzerdefinierte Verschiebungszuweisungsoperatoren verfügen.

is_move_constructible

Testet, ob der Typ einen Bewegungskonstruktor aufweist.

template <class T>
struct is_move_constructible;

Parameter

T
Der auszuwertende Typ.

Hinweise

Ein Typprädikat, das "true" auswertet, wenn der Typ T mithilfe eines Verschiebungsvorgangs erstellt werden kann. Das Prädikat entspricht is_constructible<T, T&&>.

is_nothrow_move_assignable

Überprüft, ob der Typ über einen nothrow Zuweisungsoperator für Verschiebungen verfügt.

template <class Ty>
struct is_nothrow_move_assignable;

Parameter

Ty
Der abzufragende Typ.

Hinweise

Eine Instanz des Typprädikats enthält "true", wenn der Typ "Ty " einen Zuweisungsoperator ohne Verschiebung aufweist, andernfalls "false".

is_nothrow_swappable

template <class T> struct is_nothrow_swappable;

is_nothrow_swappable_with

template <class T, class U> struct is_nothrow_swappable_with;

is_swappable

template <class T> struct is_swappable;

is_swappable_with

template <class T, class U> struct is_swappable_with;

is_trivially_copy_assignable

Testet, ob der Typ einen trivialen Kopierzuweisungsoperator aufweist.

template <class Ty>
struct is_trivially_copy_assignable;

Parameter

T
Der abzufragende Typ.

Hinweise

Eine Instanz des Typprädikats enthält "true", wenn der Typ T eine Klasse ist, die über einen Operator für triviale Kopierzuweisungen verfügt, andernfalls "false".

Ein Zuweisungskonstruktor für eine Klasse T ist trivial, wenn sie implizit bereitgestellt wird, die Klasse T keine virtuellen Funktionen hat, die Klasse T keine virtuellen Basen, die Klassen aller nicht statischen Datenmember des Klassentyps haben triviale Zuordnungsoperatoren, und die Klassen aller nicht statischen Datenmember des Typarrays der Klasse weisen triviale Zuordnungsoperatoren auf.

is_trivially_move_assignable

Testet, ob der Typ einen trivialen Verschiebezuweisungsoperator aufweist.

template <class Ty>
struct is_trivially_move_assignable;

Parameter

Ty
Der abzufragende Typ.

Hinweise

Eine Instanz des Typprädikats enthält "true", wenn der Typ "Ty" eine Klasse ist, die über einen trivialen Zuweisungsoperator verfügt, andernfalls "false".

Ein Verschiebungszuweisungsoperator für eine Klasse Ty ist trivial, wenn:

Er wird impliziert bereitgestellt

die Klasse Ty hat keine virtuellen Funktionen

die Klasse Ty hat keine virtuellen Basen

Die Klassen aller nicht statischen Datenmember des Klassentyps haben triviale Verschiebungszuweisungsoperatoren

Die Klassen aller nicht statischen Datenmember des Typarrays der Klasse haben triviale Verschiebungszuweisungsoperatoren

is_trivially_move_constructible

Testet, ob der Typ einen trivialen Bewegungskonstruktor aufweist.

template <class Ty>
struct is_trivially_move_constructible;

Parameter

Ty
Der abzufragende Typ.

Hinweise

Eine Instanz des Typprädikats enthält "true", wenn der Typ "Ty" eine Klasse mit einem trivialen Verschiebungskonstruktor ist, andernfalls "false".

Ein Verschiebungskonstruktor für eine Klasse Ty ist trivial, wenn:

Er wird implizit deklariert.

die Parametertypen entsprechen den einer impliziten Deklaration

die Klasse Ty hat keine virtuellen Funktionen

die Klasse Ty hat keine virtuellen Basen

die Klasse verfügt über keine flüchtigen nicht statischen Datenmember

alle direkten Basen der Klasse Ty haben triviale Verschiebungskonstruktoren

die Klassen aller nicht statischen Datenmember des Klassentyps haben triviale Bewegungskonstruktoren

die Klassen aller nicht statischen Datenmember vom Typarray der Klasse haben triviale Bewegungskonstruktoren

Siehe auch

<type_traits>