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-квалификатором или ref-квалификатором), предоставляет константу-член 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

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

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

DR	Применяется к	Опубликованное поведение	Корректное поведение
LWG 2196	C++11	поведение было неясным, если T&& нельзя сформировать	в этом случае возвращается значение `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/cpp/types/is_move_assignable