std:: is_move_constructible, std:: is_trivially_move_constructible, std:: is_nothrow_move_constructible

Wenn T kein vollständiger Typ ist, (möglicherweise cv-qualifiziert) void , oder ein Array unbekannter Größe, ist das Verhalten undefiniert.

Wenn eine Instanziierung einer Vorlage oben direkt oder indirekt von einem unvollständigen Typ abhängt und diese Instanziierung ein anderes Ergebnis liefern könnte, wenn dieser Typ hypothetisch vervollständigt würde, ist das Verhalten undefiniert.

Wenn das Programm Spezialisierungen für irgendwelche der auf dieser Seite beschriebenen Templates hinzufügt, ist das Verhalten undefiniert.

Hilfsvariablen-Templates

Mögliche Implementierung

template<class T>
struct is_move_constructible :
    std::is_constructible<T, typename std::add_rvalue_reference<T>::type> {};
template<class T>
struct is_trivially_move_constructible :
    std::is_trivially_constructible<T, typename std::add_rvalue_reference<T>::type> {};
template<class T>
struct is_nothrow_move_constructible :
    std::is_nothrow_constructible<T, typename std::add_rvalue_reference<T>::type> {};

Hinweise

Typen ohne Move-Konstruktor, aber mit einem Kopierkonstruktor, der const T & Argumente akzeptiert, erfüllen std::is_move_constructible .

Move-Konstruktoren sind in der Regel noexcept, da sie sonst in jedem Code, der eine starke Ausnahmesicherheitsgarantie bietet, unbrauchbar wären.

In vielen Implementierungen prüft std::is_nothrow_move_constructible auch, ob der Destruktor wirft, da es effektiv noexcept ( T ( arg ) ) ist. Gleiches gilt für std::is_trivially_move_constructible , das in diesen Implementierungen ebenfalls erfordert, dass der Destruktor trivial ist: GCC bug 51452 , LWG issue 2116 .

Beispiel

#include <string>
#include <type_traits>
struct Ex1
{
    std::string str; // Member hat einen nicht-trivialen aber nicht-werfenden Move-Konstruktor
};
static_assert(std::is_move_constructible_v<Ex1>);
static_assert(!std::is_trivially_move_constructible_v<Ex1>);
static_assert(std::is_nothrow_move_constructible_v<Ex1>);
struct Ex2
{
    int n;
    Ex2(Ex2&&) = default; // trivial und nicht-werfend
};
static_assert(std::is_move_constructible_v<Ex2>);
static_assert(std::is_trivially_move_constructible_v<Ex2>);
static_assert(std::is_nothrow_move_constructible_v<Ex2>);
struct NoMove1
{
    // verhindert die implizite Deklaration des Standard-Move-Konstruktors;
    // die Klasse ist jedoch trotzdem move-konstruierbar, weil ihr
    // Kopierkonstruktor an ein Rvalue-Argument binden kann
    NoMove1(const NoMove1&) {}
};
static_assert(std::is_move_constructible_v<NoMove1>);
static_assert(!std::is_trivially_move_constructible_v<NoMove1>);
static_assert(!std::is_nothrow_move_constructible_v<NoMove1>);
struct NoMove2
{
    // Nicht move-konstruierbar, da die Lvalue-Referenz
    // nicht an das Rvalue-Argument binden kann
    NoMove2(NoMove2&) {}
};
static_assert(!std::is_move_constructible_v<NoMove2>);
static_assert(!std::is_trivially_move_constructible_v<NoMove2>);
static_assert(!std::is_nothrow_move_constructible_v<NoMove2>);
int main() {}

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch