C++ Introspezione

Da Andreabont's Wiki.

C++ è un linguaggio compilato, quindi fatica ad avere mezzi per l'introspezione, nonostante ciò è possibile ottenere delle informazioni a run-time dello stato del codice, tramite funzioni native, librerie esterne e servizi del sistema operativo.

Type info

Nella libreria standard è disponibile l'operatore TypeID, che permette di ottenere a run-time il tipo di una variabile (anche attraverso un puntatore) e permettendo quindi di fare controlli in tal senso. E' utile per gestire l'ereditarietà o i puntatori. (Per usarlo bisogna includere l'header typeinfo)

int i;
int * pi;

std::cout << "int is: " << typeid(int).name() << " (" << typeid(int).hash_code() << ")" << std::endl;
std::cout << "  i is: " << typeid(i).name() << " (" << typeid(i).hash_code() << ")" << std::endl;
std::cout << " pi is: " << typeid(pi).name() << " (" << typeid(pi).hash_code() << ")" << std::endl;
std::cout << "*pi is: " << typeid(*pi).name() << " (" << typeid(*pi).hash_code() << ")" << std::endl;

Metodi

  • name(): Questo metodo restituisce una stringa contenente il nome del tipo (in nome dipende dall'name mangling, e può essere decodificato, vedere C++ Demangle)
  • hash_code(): Questo metodo retsituisce il codice univoco associato al tipo dal compilatore, utile per effettuare confronti.

Traits

I traits sono un modo fornito dalla libreria standard del C++ per lavorare con i tipi a compile-time, molto utile nei template per risolvere i tipi da cui si dipende e prendere decisioni in base ad essi.

Iterator traits

Tramite questo strumento è possibile accedere ai traits specifici per gli iteratori standard.

std::iterator_traits<T>::value_type        # Tipo del valore
std::iterator_traits<T>::pointer           # Tipo del puntatore al valore
std::iterator_traits<T>::reference         # Tipo del riferimento al valore
std::iterator_traits<T>::iterator_category # Tipo di iteratore utilizzato
std::iterator_traits<T>::difference_type   # Tipo della differenza tra iteratori

Allocator traits

Tramite questo strumento è possibile accedere ai traits specifici per gli allocatori standard.

std::allocator_traits<T>::value_type        # Tipo del valore
std::allocator_traits<T>::pointer           # Tipo del puntatore al valore
std::allocator_traits<T>::size_type         # Tipo della dimensione
std::allocator_traits<T>::allocator_type    # Tipo di allocatore utilizzato
std::allocator_traits<T>::difference_type   # Tipo della differenza

Pointer traits

Tramite questo strumento è possibile accedere ai traits specifici per i puntatori standard.

std::pointer_traits<T>::element_type        # Tipo dell'elemento puntato
std::pointer_traits<T>::difference_type     # Tipo della differenza tra puntatori

Type traits

Con questo header della libreria standard è possibile usare una serie di template che forniscono informazioni sui tipi a run-time, le quali informazioni sono però decise a compile-time. Per usarlo è necessario includere "type_traits".

Tipi primari

Codice Descrizione
std:: is_integral<my_value>::value
True se my_value è di un tipo integrale
std::is_floating_point<my_value>::value
True se my_value è di un tipo in virgola mobile
std::is_array<my_value>::value
True se my_value è un array primitivo
std::is_enum<my_value>::value
True se my_value è una enum
std::is_union<my_value>::value
True se my_value è una union
std::is_class<my_value>::value
True se my_value è una classe
std::is_function<my_value>::value
True se my_value è una funzione
std::is_void<my_value>::value
True se my_value è void
std::is_pointer<my_value>::value
True se my_value è un puntatore
std::is_null_pointer<my_value>::value
True se my_value è std::nullptr_t
std::is_lvalue_reference<my_value>::value
True se my_value è un riferimento a un lvalue
std::is_rvalue_reference<my_value>::value
True se my_value è un riferimento a un rvalue

Classi

Codice Descrizione
std::is_abstract<my_type>::value
True se my_type dichiara o ederita metodi virtuali puri.
std::is_base_of<my_type_1, my_type_2>
True se my_type_2 deriva da my_type_1.
std::is_default_constructible<my_type>::value
True se my_type ha il costruttore di default accessibile.
std::is_move_assignable<my_type>
True se my_type ha il costruttore di spostamento accessibile.
std::is_destructible<my_type>
True se my_type ha il distruttore accessibile.

Extra

Codice Descrizione
std::common_type<T, U>::type
Restituisce il tipo comune tra quelli passati
std::is_convertible<my_type_1, my_type_2>::value
True se è possibile eseguire un cast implicito tra i tipi