<type_traits> funzioni
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
Verifica se un valore di tipo From può essere assegnato a un tipo A .
template <class To, class From>
struct is_assignable;
Parametri
Per
Il tipo di oggetto che riceve l'assegnazione.
Da
Il tipo di oggetto che fornisce il valore.
Osservazioni:
L'espressione non valutata declval<To>() = declval<From>() deve essere nel formato corretto. Sia From che To devono essere tipi completi, voido matrici di limiti sconosciuti.
is_copy_assignable
Test se è il tipo può essere copiato in un'assegnazione.
template <class Ty>
struct is_copy_assignable;
Parametri
Ty
Tipo su cui eseguire una query.
Osservazioni:
Un'istanza del predicato di tipo contiene true se il tipo Ty è una classe con un operatore di assegnazione di copia, altrimenti contiene false. Equivalente a is_assignable<Ty&, const Ty&>.
is_copy_constructible
Verifica se il tipo ha un costruttore di copia.
template <class Ty>
struct is_copy_constructible;
Parametri
Ty
Tipo su cui eseguire una query.
Osservazioni:
Un'istanza del predicato di tipo contiene true se il tipo Ty è una classe con un costruttore di copia, altrimenti contiene false.
Esempio
#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
Verifica se il tipo ha un costruttore predefinito.
template <class Ty>
struct is_default_constructible;
Parametri
T
Tipo su cui eseguire una query.
Osservazioni:
Un'istanza del predicato di tipo contiene true se il tipo T è un tipo di classe con un costruttore predefinito, altrimenti contiene false. Equivale al predicato is_constructible<T>. Il tipo T deve essere un tipo completo, voido una matrice di limiti sconosciuti.
Esempio
#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
Verifica se il tipo può essere assegnato mediante spostamento.
template <class T>
struct is_move_assignable;
Parametri
T
Tipo su cui eseguire una query.
Osservazioni:
Un tipo può essere assegnato mediante spostamento se un riferimento rvalue a tale tipo può essere assegnato a un riferimento al tipo stesso. Il predicato del tipo è equivalente a is_assignable<T&, T&&>. I tipi assegnabili mediante spostamento includono tipi scalari referenziabili e tipi di classe con operatori di assegnazione mediante spostamento generati dal compilatore o definiti dall'utente.
is_move_constructible
Verifica se il tipo ha un costruttore di spostamento.
template <class T>
struct is_move_constructible;
Parametri
T
Il tipo da valutare
Osservazioni:
Predicato di tipo che restituisce true se il tipo T può essere costruito usando un'operazione di spostamento. Questo predicato è equivalente a is_constructible<T, T&&>.
is_nothrow_move_assignable
Verifica se il tipo dispone di un nothrow operatore di assegnazione di spostamento.
template <class Ty>
struct is_nothrow_move_assignable;
Parametri
Ty
Tipo su cui eseguire una query.
Osservazioni:
Un'istanza del predicato di tipo contiene true se il tipo Ty dispone di un operatore di assegnazione di spostamento nothrow, altrimenti contiene 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
Verifica se il tipo ha un operatore di assegnazione di copia semplice.
template <class Ty>
struct is_trivially_copy_assignable;
Parametri
T
Tipo su cui eseguire una query.
Osservazioni:
Un'istanza del predicato di tipo contiene true se il tipo T è una classe con un operatore di assegnazione di copia semplice, altrimenti contiene false.
Un costruttore di assegnazione per una classe T è semplice se viene fornito in modo implicito, la classe T non dispone di funzioni virtuali, la classe T non ha basi virtuali, le classi di tutti i membri dati non statici del tipo di classe hanno operatori di assegnazione semplici e le classi di tutti i membri dati non statici di tipo matrice di classi hanno operatori di assegnazione semplici.
is_trivially_move_assignable
Verifica se il tipo ha un operatore di assegnazione di spostamento semplice.
template <class Ty>
struct is_trivially_move_assignable;
Parametri
Ty
Tipo su cui eseguire una query.
Osservazioni:
Un'istanza del predicato di tipo contiene true se il tipo Ty è una classe con un operatore di assegnazione di spostamento semplice, altrimenti contiene false.
Un operatore di assegnazione di spostamento per una classe Ty è semplice se:
viene fornito in modo implicito
la classe Ty non dispone di funzioni virtuali
la classe Ty non ha basi virtuali
le classi di tutti i membri dati non statici del tipo di classe hanno operatori di assegnazione di spostamento semplici
le classi di tutti i membri dati non statici di tipo matrice della classe hanno operatori di assegnazione di spostamento semplici
is_trivially_move_constructible
Verifica se il tipo ha un costruttore di spostamento semplice.
template <class Ty>
struct is_trivially_move_constructible;
Parametri
Ty
Tipo su cui eseguire una query.
Osservazioni:
Un'istanza del predicato di tipo contiene true se il tipo Ty è una classe con un costruttore di spostamento semplice, altrimenti contiene false.
Un costruttore di spostamento per una classe Ty è semplice se:
viene dichiarato in modo implicito
i tipi di parametro sono equivalenti a quelli di una dichiarazione implicita
la classe Ty non dispone di funzioni virtuali
la classe Ty non ha basi virtuali
la classe non ha alcun membro dati non statici volatili
tutte le basi dirette della classe Ty hanno costruttori di spostamento semplici
le classi di tutti i membri dati non statici del tipo di classe hanno costruttori di spostamento semplici
le classi di tutti i membri dati non statici di tipo matrice della classe hanno costruttori di spostamento semplici