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

Определён в заголовке `<type_traits>`
template< class T > struct is_move_constructible;	(1)	(начиная с C++11)
template< class T > struct is_trivially_move_constructible;	(2)	(начиная с C++11)
template< class T > struct is_nothrow_move_constructible;	(3)	(начиная с C++11)

1) Если T не является типом, на который можно ссылаться (то есть возможно, типом void с cv-квалификаторами или типом функции с cv-qualifier-seq либо ref-qualifier), предоставляет константу-член value со значением false. В противном случае предоставляет константу-член value со значением std::is_constructible<T, T&&>::value.

2) То же, что и (1), но используется std::is_trivially_constructible<T, T&&>.

3) То же, что и (1), но используется std::is_nothrow_constructible<T, T&&>.

Если T не является полным типом, типом void (возможно, с cv-квалификаторами) или массивом неизвестной границы, поведение не определено.

Если инстанцирование шаблона выше прямо или косвенно зависит от неполного типа и это инстанцирование могло бы дать другой результат, если бы этот тип был гипотетически завершён, поведение не определено.

Если программа добавляет специализации для любого из шаблонов, описанных на этой странице, поведение не определено.

Вспомогательные шаблоны переменных

template< class T >
inline constexpr bool is_move_constructible_v =
    is_move_constructible<T>::value;

(начиная с C++17)

template< class T >
inline constexpr bool is_trivially_move_constructible_v =
    is_trivially_move_constructible<T>::value;

(начиная с C++17)

template< class T >
inline constexpr bool is_nothrow_move_constructible_v =
    is_nothrow_move_constructible<T>::value;

(начиная с C++17)

Унаследовано от std::integral_constant

Константы-члены

value

[static]

true, если T допускает перемещающее конструирование, false в противном случае
(открытая статическая константа-член)

Функции-члены

operator bool	преобразует объект в bool, возвращает `value` (открытая функция-член)
operator() (C++14)	возвращает `value` (открытая функция-член)

Типы-члены

Тип	Определение
`value_type`	bool
`type`	std::integral_constant<bool,value>

Возможная реализация

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

Примечания

Типы без конструктора перемещения, но с конструктором копирования, принимающим аргументы const T&, удовлетворяют условию std::is_move_constructible.

Конструкторы перемещения обычно объявляются noexcept, поскольку иначе они непригодны в коде, обеспечивающем строгую гарантию исключений.

Во многих реализациях std::is_nothrow_move_constructible также проверяет, выбрасывает ли исключения деструктор, поскольку фактически это noexcept(T(arg)). То же относится к std::is_trivially_move_constructible, для которого в этих реализациях также требуется тривиальный деструктор: ошибка GCC 51452, обсуждение LWG 2116.

Пример

#include <string>
#include <type_traits>

struct Ex1
{
    std::string str; // member has a non-trivial but non-throwing move constructor
};
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 and non-throwing
};
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
{
    // prevents implicit declaration of default move constructor;
    // however, the class is still move-constructible because its
    // copy constructor can bind to an rvalue argument
    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
{
    // Not move-constructible since the lvalue reference
    // can't bind to the rvalue argument
    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() {}

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были применены задним числом к ранее опубликованным стандартам C++.

Отчёт об ошибке	Применяется к	Опубликованное поведение	Правильное поведение
LWG 2196	C++11	поведение было неясным, если T&& нельзя сформировать	в этом случае возвращается значение `false`

См. также

is_constructibleis_trivially_constructibleis_nothrow_constructible (C++11)(C++11)(C++11)	проверяют, есть ли у типа конструктор для заданных аргументов (шаблон класса)
is_default_constructibleis_trivially_default_constructibleis_nothrow_default_constructible (C++11)(C++11)(C++11)	проверяют, есть ли у типа конструктор по умолчанию (шаблон класса)
is_copy_constructibleis_trivially_copy_constructibleis_nothrow_copy_constructible (C++11)(C++11)(C++11)	проверяют, есть ли у типа конструктор копирования (шаблон класса)
move_constructible (C++20)	задаёт требование, согласно которому объект типа может быть сконструирован перемещением (концепт)
move (C++11)	преобразует аргумент в xvalue (шаблон функции)
move_if_noexcept (C++11)	преобразует аргумент в xvalue, если конструктор перемещения не выбрасывает исключений (шаблон функции)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/types/is_move_constructible