Exemples viables C ++ RTTI

Question

Je suis familier avec le C++ RTTI, et de trouver le concept intéressant.

Encore, il existe beaucoup d'autres façons d'en abuser que de l'utiliser correctement (RTTI-commutateur d'effroi vient à l'esprit). En tant que développeur, j'ai trouvé (et utilisé) seulement deux viable utilise pour cela (plus exactement, un an et demi).

Pourriez-vous partager quelques-uns des moyens RTTI est une solution viable à un problème, avec des exemples de code/code pseudo-inclus?

Remarque: L'objectif est de disposer d'un référentiel de viable exemples, un développeur junior peuvent consulter, de critiquer et d'apprendre.

Edit: Vous trouverez ci-dessous le code à l'aide de C++ RTTI

// A has a virtual destructor (i.e. is polymorphic)
// B has a virtual destructor (i.e. is polymorphic)
// B does (or does not ... pick your poison) inherits from A

void doSomething(A * a)
{
   // typeid()::name() returns the "name" of the object (not portable)
   std::cout << "a is [" << typeid(*a).name() << "]"<< std::endl ;

   // the dynamic_cast of a pointer to another will return NULL is
   // the conversion is not possible
   if(B * b = dynamic_cast<B *>(a))
   {
      std::cout << "a is b" << std::endl ;
   }
   else
   {
      std::cout << "a is NOT b" << std::endl ;
   }
}

Answer 1

Le visiteur acyclique (pdf) en est une excellente utilisation.

Answer 2

Que diriez-vous du boost :: n'importe quel objet!

Cela utilise essentiellement les informations RTTI pour stocker n'importe quel objet et la récupération de cet objet utilise boost :: any_cast <>.

Answer 3

Vous pouvez utiliser RTTI avec dynamic_cast pour obtenir un pointeur sur une classe dérivée afin de l'utiliser pour appeler un algorithme spécialisé de type rapide. Et au lieu d'utiliser les méthodes virtuelles via la classe de base, il effectuera des appels directs et intégrés.

Cela m'a beaucoup accéléré en utilisant GCC. Visual Studio ne semble pas faire aussi bien, il peut avoir une recherche dynamic_cast plus lente.

Exemple:

 D* obj = dynamic_cast<D*>(base);
if (obj) {
    for(unsigned i=0; i<1000; ++i)
        f(obj->D::key(i));
    }
} else {
    for(unsigned i=0; i<1000; ++i)
        f(base->key(i));
    }
}
 

Answer 4

Je ne peux pas dire que j'ai jamais trouvé une utilisation dans la vie réelle, mais RTTI est mentionné dans C ++ efficace comme une solution possible aux multi-méthodes en C ++. En effet, la répartition des méthodes se fait sur le type dynamique du paramètre this mais sur le type statique des arguments.

 class base
{
  void foo(base *b) = 0; // dynamic on the parameter type as well
};

class B : public base {...}
class B1 : public B {...}
class B2 : public B {...}

class A : public base
{
  void foo(base *b)
  {
    if (B1 *b1=dynamic_cast<B1*>(b))
      doFoo(b1);
    else if (B2 *b2=dynamic_cast<B2*>(b))
      doFoo(b2);
  }
};
 

Answer 5

- Je l'utiliser dans une classe de l'arbre qui sérialise à un fichier XML. Sur la dé-sérialisation, l'analyseur de classe renvoie un pointeur vers la classe de base qui a une énumération pour le type de la sous-classe (parce que vous ne savez pas quel type c'est jusqu'à ce que vous l'analyser). Si le code à l'aide de l'objet doit de référence de la sous-classe des éléments spécifiques, il passe sur la valeur d'enum et dynamic_cast à la sous-classe (qui a été créé par l'analyseur). De cette façon, le code est possible de vérifier que l'analyseur n'a pas eu une erreur et un décalage entre la valeur d'enum et la classe de l'instance de type retourné. Les fonctions virtuelles sont également pas suffisant, car vous pourriez avoir de la sous-classe spécifique de données dont vous avez besoin pour obtenir.

C'est juste un exemple de cas où RTTI pourrait être utile; c'est peut-être pas la façon la plus élégante de résoudre le problème, mais l'utilisation de RTTI rend l'application plus robuste lors de l'utilisation de ce modèle.