RTTI

La RTTI (RunTime Type Information o RunTime Type Identification) consente ai programmi che manipolano puntatori e riferimenti ad oggetti di una classe base, di determinare il tipo dell'oggetto durante l'esecuzione invece che solo al momento della compilazione.

Questa caratteristica è utile nei programmi in cui si ha l'esigenza di aggiungere una qualche funzione virtuale ad una gerarchia di classi, ma non si ha accesso al codice sorgente di queste classi. Infatti, l'aggiunta di questa funzione personale comporta la ricompilazione di tutte le funzioni membro che ne fanno uso. Questo è particolarmente vero per le librerie realizzate da terze parti: si hanno a disposizione soltanto i file header e la versione già compilata, ma non il codice sorgente. In questa situazione non è possibile effettuare la ricompilazione.

Per i dettagli su come gestire questa caratteristica si rimanda alla documentazione del proprio linguaggio di programmazione.

RTTI, come termine è tipicamente utilizzato in relazione al C++. Per far sì che le operazioni che coinvolgono il dynamic_cast<>, l'operatore typeid o le eccezioni funzionino in C++, l'RTTI deve essere abilitato.

Esempio in C++

/*
 * Un puntatore ad una classe base può puntare a oggetti di ogni classe che sia
 * derivata da essa.
 * L'RTTI è utile per identificare quale tipo di (classe derivata) oggetto sia
 * puntato da un puntatore di classe base.
 */
 
#include <iostream>

class Abc   // classe base
{
public:
  virtual void hello() 
  {
    std::cout << "in Abc";
  }
};

class Xyz : public Abc
{
  public:
  void hello() 
  {
    std::cout << "in Xyz";
  }
};

int main()
{
  Abc *abc_pointer = new Xyz();
  Xyz *xyz_pointer;

  // per capire se abc_pointer sta puntando a un oggetto di tipo Xyz
  xyz_pointer = dynamic_cast<Xyz*>(abc_pointer);

  if (xyz_pointer != nullptr) {
    std::cout << "il puntatore abc sta puntando ad un oggetto di tipo Xyz";   // identificato
  } else {
    std::cout << "il puntatore abc NON sta puntando ad un oggetto di tipo Xyz";
  }

  return 0;
}

Un esempio in cui l'RTTI è utilizzato è illustrato qui sotto:

class Base {
  virtual ~Base(){}
};

class Derivata : public Base {
  public:
    virtual ~Derivata(){}
    int compara (Derivata &ref);
};

int mio_metodo_di_comparazione_per_un_sort_generico (Base &ref1, Base &ref2)
{
  Derivata & d = dynamic_cast<Derivata &>(ref1); // RTTI usato qui
  // RTTI fa lanciare al processo una bad_cast exception
  // se il cast non ha successo
  return d.compara (dynamic_cast<Derivata &>(ref2));
}