Vérifiez récursivement la super classe type_info

Question

Existe-t-il un moyen de vérifier quel est le type_info d'une superclasse ?Dans mon système, les objets sont identifiés par un ensemble de bits.Qui est identifié par le hashcode type_info.J'aimerais que certains de ces types activent le polymorphisme dans le sens où mon système pense qu'ils sont sous le même bit.type_info crée un hashcode unique pour chaque type de classe.Au lieu de cela, je veux que les classes dérivées prennent le jeu de bits de leur superclasse comme ceci :

Component > ISomeInterfaceComponent -> bit = 00001
              |
               \ ComponentContextA  -> bit = ISomeInterFaceComponent bit
              |
              \  ComponentContextB  -> bit = ISomeInterFaceComponent bit
              |
              \  ComponentContextC  -> bit = ISomeInterFaceComponent bit

Cela devrait ajouter l'objet contenant les composants à un système pour le traitement.

Pour le moment, voici ce qui se passe :

Component > ISomeInterFaceComponent -> bit = 00001
              |
               \ ComponentContextA  -> bit = 00010
              |
              \  ComponentContextB  -> bit = 00100
              |
              \  ComponentContextC  -> bit = 01000

Ce qui exige que je crée des systèmes différents pour tous les composants.

Si quelqu'un pouvait me donner des indications sur la manière d'y parvenir, ce serait formidable.

Modifier:Pour éviter toute confusion et définir un type, procédez comme suit :ComponentTypeManager :: getBit ();

Je ne travaille donc pas avec des instances.Et j’aimerais garder le système actuel verrouillé.

Answer 1

À ma connaissance, il n'existe aucun moyen automatique.Cependant, si je vous comprends, cela peut être fait moyennant un petit effort supplémentaire.

Pour chacune de vos classes « de base », ajoutez un typedef qui fait référence à lui-même et utilisez-le à la place dans le typeid().Notez que les sous-classes peuvent choisir de le remplacer.S’ils le font, ils obtiendront leur propre pièce d’identité et leurs enfants utiliseront leur valeur.

Attention, une autre solution, si vous ne souhaitez pas utiliser typeid() est d'avoir un membre statique (ou une fonction membre) sur les classes de base qui renvoie la valeur appropriée pour la base, puis de l'invoquer directement dans votre fonction getBit().

#include <iostream>
#include <iomanip>
#include <typeinfo>

struct Base1 
{
   typedef Base1 Base;

};

struct Base2
{
   typedef Base2 Base;
};

struct Derived1A : public Base1 { };   
struct Derived1B : public Base1 { };    
struct Derived2A : public Base2 { };    
struct Derived2B : public Base2 { };

template <typename T>
std::size_t getBit()
{
   // Do whatever you normally do here, but use T::Base instead of T
   return std::hash<std::string>()(typeid(typename T::Base).name());
}

int main()
{ 
   std::cout << std::boolalpha << getBit<Derived1A>() << " == " << getBit<Derived1B>() << " " << (getBit<Derived1A>() == getBit<Derived1B>()) << "\n";

   std::cout << std::boolalpha << getBit<Derived2A>() << " == " << getBit<Derived2B>() << " " <<(getBit<Derived2A>() == getBit<Derived2B>()) << "\n";

}

http://ideone.com/6ad08

Answer 2

Pourquoi ne pas simplement créer une variable dans la classe de base ISomeInterFaceComponent qui n'est modifié par aucune classe dérivée (sauf si vous le souhaitez spécifiquement).Il ne semble pas que vous vouliez du polymorphisme, car vous voulez que la valeur du bit soit la même quel que soit le type de classe dérivée, plutôt que de varier en fonction du type.Si à l'avenir vous devez remplacer if pour un certain type dérivé, vous pouvez toujours le faire spécifiquement pour cette classe.

Alternativement, vous pouvez utiliser une fonction virtuelle dans la classe de base qui renvoie un int (la valeur binaire - ou quel que soit le type dont il s'agit réellement) et simplement ne pas la remplacer dans les classes dérivées dont vous souhaitez avoir la même valeur binaire que la base.

Par exemple

 class ISomeInterFaceComponent {
      virtual int GetBit() { return 1;};  // return bit value
 };


 class ComponentContextA : public ISomeInterFaceComponent {
      // Do not override GetBit() - let the base class function get called.
 };