RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/language/../algorithm/../ranges/../types/is_assignable.html below:

std::is_assignable, std::is_trivially_assignable, std::is_nothrow_assignable - cppreference.com

template< class T, class U > struct is_assignable;

(1) (since C++11)

template< class T, class U > struct is_trivially_assignable;

(2) (since C++11)

template< class T, class U > struct is_nothrow_assignable;

(3) (since C++11) 1)

If the expression

std::declval<T>() = std::declval<U>()

is well-formed in unevaluated context, provides the member constant

value

equal to

true

. Otherwise,

value

false

Access checks

are performed as if from a context unrelated to either type.

2)

Same as

(1)

, but the evaluation of the assignment expression will not call any operation that is not trivial. For the purposes of this check, a call to

std::declval

is considered trivial and not considered an

odr-use

std::declval

3) Same as (1), but the evaluation of the assignment expression will not call any operation that is not noexcept.

If T or U is not a complete type, (possibly cv-qualified) void, or an array of unknown bound, the behavior is undefined.

If an instantiation of a template above depends, directly or indirectly, on an incomplete type, and that instantiation could yield a different result if that type were hypothetically completed, the behavior is undefined.

If the program adds specializations for any of the templates described on this page, the behavior is undefined.

[edit] Helper variable templates

template< class T, class U > constexpr bool is_assignable_v = is_assignable<T, U>::value;

(since C++17)

template< class T, class U > constexpr bool is_trivially_assignable_v = is_trivially_assignable<T, U>::value;

(since C++17)

template< class T, class U > constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<T, U>::value;

(since C++17) Inherited from std::integral_constant Member constants true if T is assignable from U, false otherwise
(public static member constant) Member functions converts the object to bool, returns value
(public member function) returns value
(public member function) Member types [edit] Notes

This trait does not check anything outside the immediate context of the assignment expression: if the use of T or U would trigger template specializations, generation of implicitly-defined special member functions etc, and those have errors, the actual assignment may not compile even if std::is_assignable<T,U>::value compiles and evaluates to true.

[edit] Example

#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';
}

Output:

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

[edit] See also

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4