fonctions<type_traits>
is_assignable
is_copy_assignable
is_copy_constructible
is_default_constructible
is_move_assignable
is_move_constructible
is_nothrow_move_assignable
is_nothrow_swappable
is_nothrow_swappable_with
is_swappable
is_swappable_with
is_trivially_copy_assignable
is_trivially_move_assignable
is_trivially_move_constructible
is_assignable
Teste si une valeur de type From peut être affectée à un type To .
template <class To, class From>
struct is_assignable;
Paramètres
Pour
Type de l'objet qui reçoit l'assignation.
De
Type de l'objet qui fournit la valeur.
Notes
L’expression non évaluée declval<To>() = declval<From>() doit être bien formée. From et To doivent être des types complets, voidou des tableaux de limites inconnues.
is_copy_assignable
Teste si le type peut être copié lors de l'assignation.
template <class Ty>
struct is_copy_assignable;
Paramètres
Ty
Type à interroger.
Notes
Une instance du prédicat de type a la valeur true si le type Ty est une classe qui a un opérateur d’affectation de copie, sinon elle contient false. Équivalent à is_assignable<Ty&, const Ty&>.
is_copy_constructible
Teste si le type a un constructeur de copie.
template <class Ty>
struct is_copy_constructible;
Paramètres
Ty
Type à interroger.
Notes
Une instance du prédicat de type a la valeur true si le type Ty est une classe qui a un constructeur de copie, sinon elle contient false.
Exemple
#include <type_traits>
#include <iostream>
struct Copyable
{
int val;
};
struct NotCopyable
{
NotCopyable(const NotCopyable&) = delete;
int val;
};
int main()
{
std::cout << "is_copy_constructible<Copyable> == " << std::boolalpha
<< std::is_copy_constructible<Copyable>::value << std::endl;
std::cout << "is_copy_constructible<NotCopyable> == " << std::boolalpha
<< std::is_copy_constructible<NotCopyable>::value << std::endl;
return (0);
}
is_copy_constructible<Copyable> == true
is_copy_constructible<NotCopyable > == false
is_default_constructible
Teste si un type a un constructeur par défaut.
template <class Ty>
struct is_default_constructible;
Paramètres
T
Type à interroger.
Notes
Une instance du prédicat de type a la valeur true si le type T est un type de classe qui a un constructeur par défaut, sinon il contient false. Cela est équivalent au prédicat is_constructible<T>. Le type T doit être un type complet, voidou un tableau de limites inconnues.
Exemple
#include <type_traits>
#include <iostream>
struct Simple
{
Simple() : val(0) {}
int val;
};
struct Simple2
{
Simple2(int v) : val(v) {}
int val;
};
int main()
{
std::cout << "is_default_constructible<Simple> == " << std::boolalpha
<< std::is_default_constructible<Simple>::value << std::endl;
std::cout << "is_default_constructible<Simple2> == " << std::boolalpha
<< std::is_default_constructible<Simple2>::value << std::endl;
return (0);
}
is_default_constructible<Simple> == true
is_default_constructible<Simple2> == false
is_move_assignable
Teste si le type peut être assigné par déplacement.
template <class T>
struct is_move_assignable;
Paramètres
T
Type à interroger.
Notes
Un type est assignable par déplacement si une référence rvalue au type peut être assignée à une référence au type. Le prédicat de type équivaut à is_assignable<T&, T&&>. Les types assignables par déplacement incluent les types scalaires référençables et les types de classe qui ont des opérateurs d’assignation par déplacement générés par le compilateur ou définis par l’utilisateur.
is_move_constructible
Teste si le type a un constructeur de déplacement.
template <class T>
struct is_move_constructible;
Paramètres
T
Type à évaluer
Notes
Prédicat de type qui prend la valeur true si le type T peut être construit à l’aide d’une opération de déplacement. Ce prédicat équivaut à is_constructible<T, T&&>.
is_nothrow_move_assignable
Teste si le type a un nothrow opérateur d’affectation de déplacement.
template <class Ty>
struct is_nothrow_move_assignable;
Paramètres
Ty
Type à interroger.
Notes
Une instance du prédicat de type a la valeur true si le type Ty a un opérateur d’affectation de déplacement de type, sinon il contient false.
is_nothrow_swappable
template <class T> struct is_nothrow_swappable;
is_nothrow_swappable_with
template <class T, class U> struct is_nothrow_swappable_with;
is_swappable
template <class T> struct is_swappable;
is_swappable_with
template <class T, class U> struct is_swappable_with;
is_trivially_copy_assignable
Teste si le type a un opérateur d'assignation de copie trivial.
template <class Ty>
struct is_trivially_copy_assignable;
Paramètres
T
Type à interroger.
Notes
Une instance du prédicat de type a la valeur true si le type T est une classe qui a un opérateur d’assignation de copie triviale, sinon elle contient false.
Un constructeur d’affectation pour une classe T est trivial s’il est implicitement fourni, la classe T n’a pas de fonctions virtuelles, la classe T n’a pas de bases virtuelles, les classes de tous les membres de données non statiques du type de classe ont des opérateurs d’affectation trivial et les classes de tous les membres de données non statiques du tableau de types de classe ont des opérateurs d’affectation triviale.
is_trivially_move_assignable
Teste si le type a un opérateur d'assignation de déplacement trivial.
template <class Ty>
struct is_trivially_move_assignable;
Paramètres
Ty
Type à interroger.
Notes
Une instance du prédicat de type a la valeur true si le type Ty est une classe qui a un opérateur d’affectation de déplacement trivial, sinon elle contient false.
Un opérateur d’affectation de déplacement pour une classe Ty est trivial si :
il est fourni implicitement ;
la classe Ty n’a pas de fonctions virtuelles
la classe Ty n’a pas de bases virtuelles
les classes de tous les membres de données non statiques de type classe possèdent des opérateurs d'assignation de déplacement triviaux ;
les classes de tous les membres de données non statiques de type tableau de classe possèdent des opérateurs d'assignation de déplacement triviaux.
is_trivially_move_constructible
Teste si le type a un constructeur de déplacement trivial.
template <class Ty>
struct is_trivially_move_constructible;
Paramètres
Ty
Type à interroger.
Notes
Une instance du prédicat de type a la valeur true si le type Ty est une classe qui a un constructeur de déplacement trivial, sinon il contient false.
Un constructeur de déplacement pour une classe Ty est trivial si :
il est déclaré implicitement ;
ses types de paramètres sont équivalents à ceux d'une déclaration implicite ;
la classe Ty n’a pas de fonctions virtuelles
la classe Ty n’a pas de bases virtuelles
la classe n'a aucun membre de données non statique volatile ;
toutes les bases directes de la classe Ty ont des constructeurs de déplacement trivials
les classes de tous les membres de données non statiques de type de classe ont des constructeurs de déplacement triviaux ;
les classes de tous les membres de données non statiques de type tableau de classe ont des constructeurs de déplacement triviaux.