Пространства имён
Варианты
Действия

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

Материал из cppreference.com
< cpp‎ | types
 
 
Библиотека метапрограммирования
Свойства типов
Категории типов
(C++11)
(C++14)  
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Свойства типов
(C++11)
(C++11)
(C++14)
(C++11)
(C++11)(до C++20*)
(C++11)(устарело в C++20)
(C++11)
Константы свойств типа
Метафункции
(C++17)
Поддерживаемые операции
is_move_assignableis_trivially_move_assignableis_nothrow_move_assignable
(C++11)(C++11)(C++11)

Запросы отношений и свойств
Модификации типов
(C++11)(C++11)(C++11)
Преобразования типов
(C++11)(устарело в C++23)
(C++11)(устарело в C++23)
(C++11)
(C++11)
(C++17)

(C++11)(до C++20*)(C++17)
Рациональная арифметика времени компиляции
Целочисленные последовательности времени компиляции
 
Определено в заголовочном файле <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-квалификаторов или ссылочным квалификатором), предоставляет константу-элемент 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 иначе
(public static константа-элемент)

Функции-элементы

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

Типы элементы

Тип Определение
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 {
    // Исключает неявное определение оператора присваивания перемещением
    // Тем не менее, класс имеет семантику присваивания перемещением,
    // так как оператор присваивания копированием может принять правосторонний аргумент
    NoMove& operator=(const NoMove&) { return *this; }
};
int main() {
    std::cout << std::boolalpha
              << "std::string имеет семантику присваивания перемещением без исключений? "
              << std::is_nothrow_move_assignable<std::string>::value << '\n'
              << "int[2] имеет семантику присваивания перемещением? "
              << std::is_move_assignable<int[2]>::value << '\n'
              << "Foo имеет тривиальную семантику присваивания перемещением? "
              << std::is_trivially_move_assignable<Foo>::value << '\n';
 
    std::cout << std::boolalpha
              << "NoMove имеет семантику присваивания перемещением? "
              << std::is_move_assignable<NoMove>::value << '\n'
              << "NoMove имеет семантику присваивания перемещением без исключений? "
              << std::is_nothrow_move_assignable<NoMove>::value << '\n';
}

Вывод:

std::string имеет семантику присваивания перемещением без исключений? true
int[2] имеет семантику присваивания перемещением? false
Foo имеет тривиальную семантику присваивания перемещением? true
NoMove имеет семантику присваивания перемещением? true
NoMove имеет семантику присваивания перемещением без исключений? false

[править] Смотрите также

проверяет, есть ли у типа оператор присваивания для определённого аргумента
(шаблон класса) [править]
проверяет, есть ли у типа оператор присваивания копированием
(шаблон класса) [править]