Solução bem conhecida para evitar a lentidão do dynamic_cast?
Eu precisava de polimorfismo em tempo de execução, então useidynamic_cast
.
Mas agora eu tive dois problemas -dynamic_cast
estavaextremamente lento! (Role para baixo para referência.)
Resumindo, acabei resolvendo o problema dessa maneira, usandostatic_cast
:
struct Base
{
virtual ~Base() { }
virtual int type_id() const = 0;
template<class T>
T *as()
{ return this->type_id() == T::ID ? static_cast<T *>(this) : 0; }
template<class T>
T const *as() const
{ return this->type_id() == T::ID ? static_cast<T const *>(this) : 0; }
};
struct Derived : public Base
{
enum { ID = __COUNTER__ }; // warning: can cause ABI incompatibility
int type_id() const { return ID; }
};
int main()
{
Base const &value = Derived();
Derived const *p = value.as<Derived>(); // "static" dynamic_cast
}
Mas eu certamente não sou a primeira pessoa a encontrar esse problema, então achei que valeria a pena perguntar:
Em vez de apresentar uma solução caseira como essa, existe um padrão / biblioteca bem conhecido que eu possa usar para resolver esse problema no futuro?
Exemplo de referênciaPara ter uma ideia do que estou falando, tente o código abaixo -dynamic_cast
foi aproximadamente15 vezes mais lento que um merovirtual
chamar na minha máquina (110 ms. contra 1620 ms. com o código abaixo):
#include <cstdio>
#include <ctime>
struct Base { virtual unsigned vcalc(unsigned i) const { return i * i + 1; } };
struct Derived1 : public Base
{ unsigned vcalc(unsigned i) const { return i * i + 2; } };
struct Derived2 : public Derived1
{ unsigned vcalc(unsigned i) const { return i * i + 3; } };
int main()
{
Base const &foo = Derived2();
size_t const COUNT = 50000000;
{
clock_t start = clock();
unsigned n = 0;
for (size_t i = 0; i < COUNT; i++)
n = foo.vcalc(n);
printf("virtual call: %d ms (result: %u)\n",
(int)((clock() - start) * 1000 / CLOCKS_PER_SEC), n);
fflush(stdout);
}
{
clock_t start = clock();
unsigned n = 0;
for (size_t i = 0; i < COUNT; i++)
n = dynamic_cast<Derived1 const &>(foo).vcalc(n);
printf("virtual call after dynamic_cast: %d ms (result: %u)\n",
(int)((clock() - start) * 1000 / CLOCKS_PER_SEC), n);
fflush(stdout);
}
return 0;
}
Quando eu simplesmente removo a palavravirtual
e mudardynamic_cast
parastatic_cast
, Recebo um tempo de execução de 79 ms - portanto, uma chamada virtual é apenas mais lenta que uma chamada estática em ~ 25%!