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)
Défini dans l'en-tête <type_traits>
template < class T, class U >
struct is_assignable ;
(1) (depuis C++11)
template < class T, class U >
struct is_trivially_assignable ;
(2) (depuis C++11)
template < class T, class U >
struct is_nothrow_assignable ;
(3) (depuis C++11)
1) Si l'expression std:: declval < T > ( ) = std:: declval < U > ( ) est bien formée dans un contexte non évalué, fournit la constante membre value égale à true . Sinon, value est false . Les vérifications d'accès sont effectuées comme depuis un contexte sans relation avec l'un ou l'autre type.
2) Identique à (1) , mais l'évaluation de l'expression d'assignation n'appellera aucune opération non triviale. Aux fins de cette vérification, un appel à std::declval est considéré comme trivial et n'est pas considéré comme une odr-use de std::declval .
3) Identique à (1) , mais l'évaluation de l'expression d'assignation n'appellera aucune opération qui n'est pas noexcept.

Si T ou U n'est pas un type complet, (éventuellement qualifié cv) void , ou un tableau de limite inconnue, le comportement est indéfini.

Si une instanciation d'un template ci-dessus dépend, directement ou indirectement, d'un type incomplet, et que cette instanciation pourrait produire un résultat différent si ce type était hypothétiquement complété, le comportement est indéfini.

Si le programme ajoute des spécialisations pour l'un des modèles décrits sur cette page, le comportement est indéfini.

Table des matières

Modèles de variables d'assistance

template < class T, class U >
constexpr bool is_assignable_v = is_assignable < T, U > :: value ;
(depuis C++17)
template < class T, class U >
constexpr bool is_trivially_assignable_v = is_trivially_assignable < T, U > :: value ;
(depuis C++17)
template < class T, class U >
constexpr bool is_nothrow_assignable_v = is_nothrow_assignable < T, U > :: value ;
(depuis C++17)

Hérité de std:: integral_constant

Constantes membres

value
[static]
true si T est assignable depuis U , false sinon
(constante membre publique statique)

Fonctions membres

operator bool
convertit l'objet en bool , retourne value
(fonction membre publique)
operator()
(C++14)
retourne value
(fonction membre publique)

Types membres

Type Définition
value_type bool
type std:: integral_constant < bool , value >

Notes

Ce trait ne vérifie rien en dehors du contexte immédiat de l'expression d'assignation : si l'utilisation de T ou U déclenchait des spécialisations de templates, la génération de fonctions membres spéciales implicitement définies, etc., et que celles-ci contiennent des erreurs, l'assignation réelle pourrait ne pas compiler même si std :: is_assignable < T,U > :: value compile et s'évalue à true .

Exemple

Exécuter ce code 
#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';
}

Sortie : 

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

Voir aussi

(C++11) (C++11) (C++11)
vérifie si un type a un opérateur d'affectation par copie
(modèle de classe)
(C++11) (C++11) (C++11)
vérifie si un type a un opérateur d'affectation par déplacement
(modèle de classe)
(C++20)
spécifie qu'un type peut être assigné à partir d'un autre type
(concept)