Namespaces
Variants

std:: is_assignable, std:: is_trivially_assignable, std:: is_nothrow_assignable

From cppreference.net
C++
Metaprogramming library
Type traits
Type categories
(C++11)
(C++11) ( DR* )
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Type properties
(C++11)
(C++11)
(C++11)
(C++11)
(C++14)
(C++11)
(C++17)
(C++23)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
(C++11) ( until C++20* )
(C++11) (deprecated in C++20)
(C++11)
(C++11)
(C++20)
(C++20)
(C++23)
(C++17)
Type trait constants
(C++11) (C++17) (C++11) (C++11)
Metafunctions
(C++17)
(C++17)
(C++17)
Supported operations
Relationships and property queries
Type modifications
Type transformations
(C++11) (deprecated in C++23)
(C++11) (deprecated in C++23)
(C++11)
(C++20)
(C++11) ( until C++20* ) (C++17)

Compile-time rational arithmetic
Compile-time integer sequences
(C++14)
Определено в заголовочном файле <type_traits>
template < class T, class U >
struct is_assignable ;
(1) (начиная с C++11)
template < class T, class U >
struct is_trivially_assignable ;
(2) (начиная с C++11)
template < class T, class U >
struct is_nothrow_assignable ;
(3) (начиная с C++11)
1) Если выражение std:: declval < T > ( ) = std:: declval < U > ( ) корректно в невычисляемом контексте, предоставляет константу-член value равную true . В противном случае value равна false . Проверки доступа выполняются так, как если бы они происходили из контекста, не связанного ни с одним из типов.
2) То же, что и (1) , но вычисление выражения присваивания не будет вызывать никаких операций, которые не являются тривиальными. Для целей данной проверки вызов std::declval считается тривиальным и не считается odr-использованием std::declval .
3) То же, что и (1) , но вычисление выражения присваивания не будет вызывать никакие операции, которые не являются noexcept.

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

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

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

Содержание

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

template < class T, class U >
constexpr bool is_assignable_v = is_assignable < T, U > :: value ;
(начиная с C++17)
template < class T, class U >
constexpr bool is_trivially_assignable_v = is_trivially_assignable < T, U > :: value ;
(начиная с C++17)
template < class T, class U >
constexpr bool is_nothrow_assignable_v = is_nothrow_assignable < T, U > :: value ;
(начиная с C++17)

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

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

value
[static]
true если T может быть присвоен из U , false в противном случае
(публичная статическая константа-член)

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

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

Типы-члены

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

Примечания

Этот признак не проверяет ничего за пределами непосредственного контекста выражения присваивания: если использование T или U вызовет специализации шаблонов, генерацию неявно определенных специальных функций-членов и т.д., и в них есть ошибки, фактическое присваивание может не компилироваться, даже если std :: is_assignable < T,U > :: value компилируется и вычисляется как true .

Пример

Запустить этот код 
#include <iostream>
#include <string>
#include <type_traits>
struct Ex1 { int n; };
int main()
{
    std::cout << std::boolalpha
              << "int is assignable from int? "
              << std::is_assignable<int, int>::value << '\n' // 1 = 1; wouldn't compile
              << "int& is assignable from int? "
              << std::is_assignable<int&, int>::value << '\n' // int a; a = 1; works
              << "int is assignable from double? "
              << std::is_assignable<int, double>::value << '\n'
              << "int& is nothrow assignable from double? "
              << std::is_nothrow_assignable<int&, double>::value << '\n'
              << "string is assignable from double? "
              << std::is_assignable<std::string, double>::value << '\n'
              << "Ex1& is trivially assignable from const Ex1&? "
              << std::is_trivially_assignable<Ex1&, const Ex1&>::value << '\n';
}

Вывод: 

int is assignable from int? false
int& is assignable from int? true
int is assignable from double? false
int& is nothrow assignable from double? true
string is assignable from double? true
Ex1& is trivially assignable from const Ex1&? true

Смотрите также

(C++11) (C++11) (C++11)
проверяет, имеет ли тип оператор копирующего присваивания
(шаблон класса)
(C++11) (C++11) (C++11)
проверяет, имеет ли тип оператор перемещающего присваивания
(шаблон класса)
(C++20)
указывает, что тип может быть присвоен из другого типа
(концепт)