Verificação de forma recursiva super classe type_info

Question

Existe uma maneira de verificar o que type_info de uma superclasse é?Na minha objetos do sistema são identificados por um conjunto de bits.O que é Identificado pela type_info hashcode.Eu gostaria de algum desses tipos para habilitar o polimorfismo no sentido de que meu sistema pensa que eles estão sob o mesmo pouco.type_info cria um único hashcode para cada tipo de classe.Em vez disso, eu quero que as classes derivadas para tomar o conjunto de bits de sua superclasse assim:

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

Isso deve adicionar o objeto que contém os componentes de um sistema para o processamento.

A partir de agora, é isto que acontece:

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

O que exige que eu criar sistemas diferentes para todos os componentes.

Se alguém poderia me dar indicações sobre como eu poderia alcançar este que seria ótimo.

Editar:Para evitar confusão para obter um conjunto de bits para um tipo vai como segue:ComponentTypeManager::getBit();

Então, eu não estou trabalhando com instâncias.E eu gostaria de manter o sistema atual de bloqueio.

Answer 1

Não existe nenhuma forma automática de que eu estou ciente.No entanto, se eu o entendo, ele pode ser feito através do pouco esforço adicional.

Para cada um dos seus 'base' classes, adicione um typedef, que refere-se a si mesmo, e usar isso ao invés de typeid().Nota, subclasses pode escolher para substituí-lo.Se eles fizerem isso, então eles vão ter seu próprio ID, e seus filhos vão utilizar a sua valor.

Observação, outra solução, se você não quiser usar typeid() em tudo é ter um membro estático (ou função de membro) sobre a base de classes que retorna o valor apropriado para a base e, em seguida, invocar diretamente no seu getBit() função.

#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

Porque não basta criar uma variável na classe base ISomeInterFaceComponent que não é modificado por classes derivadas (a menos que você especificamente deseja que ele seja).Ele não soar como você quiser polimorfismo como você deseja que o valor do bit a ser o mesmo independentemente da classe derivada tipo, em vez de variar com base no tipo.Se no futuro você precisar de substituir-se por um determinado tipo derivado, você ainda pode fazer isso, especificamente para essa classe.

Como alternativa, você pode utilizar uma função virtual na classe base que retorna um int (o valor do bit - ou qualquer que seja o tipo, isso realmente é) e que, simplesmente, não substituí-lo em classes derivadas que você deseja ter o mesmo valor do bit como base.

Por exemplo

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