std::is_move_assignable, std::is_trivially_move_assignable, std::is_nothrow_move_assignable

Определено в заголовке `<type_traits>`
template< class T > struct is_move_assignable;	(1)	(с C++11)
template< class T > struct is_trivially_move_assignable;	(2)	(с C++11)
template< class T > struct is_nothrow_move_assignable;	(3)	(с C++11)

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

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

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

T должен быть полным типом, (возможно, с квалификаторами cv) void или массивом неизвестной длины. В противном случае поведение не определено.

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

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

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

template< class T >
inline constexpr bool is_move_assignable_v =
    is_move_assignable<T>::value;

(с C++17)

template< class T >
inline constexpr bool is_trivially_move_assignable_v =
    is_trivially_move_assignable<T>::value;

(с C++17)

template< class T >
inline constexpr bool is_nothrow_move_assignable_v =
    is_nothrow_move_assignable<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_assignable
    : std::is_assignable<typename std::add_lvalue_reference<T>::type,
                         typename std::add_rvalue_reference<T>::type> {};
 
template<class T>
struct is_trivially_move_assignable
    : std::is_trivially_assignable<typename std::add_lvalue_reference<T>::type,
                                   typename std::add_rvalue_reference<T>::type> {};
 
template<class T>
struct is_nothrow_move_assignable
    : std::is_nothrow_assignable<typename std::add_lvalue_reference<T>::type,
                                 typename std::add_rvalue_reference<T>::type> {};

Примечания

Характеристика std::is_move_assignable менее строга, чем MoveAssignable, так как она не проверяет тип результата присваивания (который для типа MoveAssignable должен быть T&), а также семантическое требование, что значение целевого объекта после присваивания эквивалентно значению исходного объекта до присваивания.

Тип не обязан реализовывать оператор перемещающего присваивания, чтобы удовлетворить этому свойству; см. MoveAssignable для подробностей.

Пример

#include <iostream>
#include <string>
#include <type_traits>
 
struct Foo { int n; };
 
struct NoMove
{
    // prevents implicit declaration of default move assignment operator
    // however, the class is still move-assignable because its
    // copy assignment operator can bind to an rvalue argument
    NoMove& operator=(const NoMove&) { return *this; }
};
 
int main()
{
    std::cout << std::boolalpha
              << "std::string is nothrow move-assignable? "
              << std::is_nothrow_move_assignable<std::string>::value << '\n'
              << "int[2] is move-assignable? "
              << std::is_move_assignable<int[2]>::value << '\n'
              << "Foo is trivially move-assignable? "
              << std::is_trivially_move_assignable<Foo>::value << '\n'
              << "NoMove is move-assignable? "
              << std::is_move_assignable<NoMove>::value << '\n'
              << "NoMove is nothrow move-assignable? "
              << std::is_nothrow_move_assignable<NoMove>::value << '\n';
}

Вывод:

std::string is nothrow move-assignable? true
int[2] is move-assignable? false
Foo is trivially move-assignable? true
NoMove is move-assignable? true
NoMove is nothrow move-assignable? false

См. также

is_assignableis_trivially_assignableis_nothrow_assignable (C++11)(C++11)(C++11)	проверяет, имеет ли тип оператор присваивания для определённого аргумента (шаблон класса)
is_copy_assignableis_trivially_copy_assignableis_nothrow_copy_assignable (C++11)(C++11)(C++11)	проверяет, имеет ли тип оператор копирующего присваивания (шаблон класса)

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