Verifique recursivamente la superclase type_info

Question

¿Hay alguna manera de comprobar cuál es el type_info de una superclase?En mi sistema los objetos se identifican mediante un conjunto de bits.Que se identifica mediante el código hash type_info.Me gustaría que algunos de estos tipos habiliten el polimorfismo en el sentido de que mi sistema piense que están bajo el mismo bit.type_info crea un código hash único para cada tipo de clase.En lugar de eso, quiero que las clases derivadas tomen el conjunto de bits de su superclase así:

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

Esto debería agregar el objeto que contiene los componentes a un sistema para su procesamiento.

A partir de ahora esto es lo que sucede:

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

Lo que exige que cree diferentes sistemas para todos los componentes.

Si alguien pudiera darme sugerencias sobre cómo podría lograr esto, sería genial.

Editar:Para evitar confusiones al configurar un bit para un tipo, es el siguiente:ComponentTypeManager::getBit();

Entonces no estoy trabajando con instancias.Y me encantaría mantener bloqueado el sistema actual.

Answer 1

No hay ninguna forma automática que yo sepa.Sin embargo, si te entiendo, se puede hacer con un pequeño esfuerzo adicional.

Para cada una de sus clases 'base', agregue un typedef que se refiera a sí mismo y utilícelo en su lugar en el typeid().Tenga en cuenta que las subclases podrían optar por anularlo.Si lo hacen, obtendrán su propia identificación y sus hijos usarán su valor.

Nota, otra solución, si no quieres usar typeid() todo es tener un miembro estático (o función miembro) en las clases base que devuelva el valor adecuado para la base, y luego invocarlo directamente en su función 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

¿Por qué no simplemente crear una variable en la clase base? ISomeInterFaceComponent que no sea modificado por ninguna clase derivada (a menos que usted desee específicamente que lo sea).No parece que quieras polimorfismo ya que quieres que el valor del bit sea el mismo independientemente del tipo de clase derivada, en lugar de variar según el tipo.Si en el futuro necesita anular if para un determinado tipo derivado, aún puede hacerlo específicamente para esa clase.

Alternativamente, puede usar una función virtual en la clase base que devuelva un int (el valor de bit, o cualquier tipo que sea) y simplemente no anularla en las clases derivadas que desee que tengan el mismo valor de bit que la base.

Por ejemplo

 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.
 };