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

Si T no es un tipo completo, (posiblemente calificado cv) void , o un array de límite desconocido, el comportamiento es indefinido.

Si una instanciación de una plantilla anterior depende, directa o indirectamente, de un tipo incompleto, y esa instanciación podría producir un resultado diferente si ese tipo se completara hipotéticamente, el comportamiento no está definido.

Si el programa añade especializaciones para cualquiera de las plantillas descritas en esta página, el comportamiento es indefinido.

Plantillas de variables auxiliares

Implementación posible

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> {};

Notas

Los tipos sin un constructor de movimiento, pero con un constructor de copia que acepta const T & argumentos, satisfacen std::is_move_constructible .

Los constructores de movimiento suelen ser noexcept, ya que de lo contrario no se pueden utilizar en ningún código que proporcione una garantía de excepción fuerte.

En muchas implementaciones, std::is_nothrow_move_constructible también verifica si el destructor lanza excepciones porque es efectivamente noexcept ( T ( arg ) ) . Lo mismo aplica para std::is_trivially_move_constructible , que, en estas implementaciones, también requiere que el destructor sea trivial: GCC bug 51452 , LWG issue 2116 .

Ejemplo

#include <string>
#include <type_traits>
struct Ex1
{
    std::string str; // el miembro tiene un constructor de movimiento no trivial pero no lanzador de excepciones
};
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 y no lanzador de excepciones
};
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
{
    // previene la declaración implícita del constructor de movimiento por defecto;
    // sin embargo, la clase sigue siendo construible por movimiento porque su
    // constructor de copia puede enlazar con un argumento de valor R
    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
{
    // No es construible por movimiento ya que la referencia de valor L
    // no puede enlazar con el argumento de valor R
    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() {}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también