¿Es LLVM una excepción a la regla para evitar conversiones dinámicas?

Question

LLVM tiene su propia alternativa a RTTI que es una mejora de velocidad con respecto al RTTI integrado y permite la transmisión dinámica a clases sin vtable (dyn_cast).Sin embargo, todavía se puede utilizar exactamente de la misma manera que dynamic_cast<> se utiliza aunque permite su uso con más clases.

dyn_cast<> documentación de plantilla

LLVM es un proyecto de C++ de buena reputación, por lo que esto parece ir en contra del dicho común de que demasiadas conversiones dinámicas es una señal de mal diseño, también conocido como olor a código.Seguramente un molde dinámico de mejor rendimiento no hace nada para mejorar su uso en el diseño que un molde estándar. dynamic_cast.Entonces, ¿quién está aquí?¿Existen casos en los que el uso a gran escala de la conversión dinámica sea una buena opción de diseño en código C++?Google encuentra 690 apariciones de este tipo de conversión dinámica en el código fuente troncal de LLVM.

Usos de dyn_cast<> en el tronco LLVM

Answer 1

Si bien los resultados de rendimiento son una razón para evitar dynamic_cast<> para las jerarquías de clases grandes, no es la única razón por la que es posible que desee evitarlos. Mejor desempeño o no, uno no debería estar más animado a usar dyn_cast<> debido a esta afirmación.

Por otro lado, no hay absolutamente nada de malo en usar goto cuando es la mejor herramienta para el trabajo. Si su uso está justificado y es la forma más limpia de resolver un problema, siempre es correcto, independientemente de & Quot; dicho común & Quot ;.

Ciertamente no me mantendría alejado de los proyectos populares simplemente porque usan <=> s, <=> so cualquier otro idioma que haya caído en desgracia.

Answer 2

Creo que los lanzamientos dinámicos son malos no porque sean lentos, sino porque implican que su código está demasiado acoplado.

Answer 3

Solo he echado un vistazo muy rápido a la implementación de dyn_cast e isa en la documentación de LLVM.

El ejemplo en el código tiene lo siguiente:

struct bar {
  bar() {}
private:
  bar(const bar &);

};
struct foo {
  void ext() const;
  /*  static bool classof(const bar *X) {
    cerr << "Classof: " << X << "\n";
    return true;
    }*/
};

template <> inline bool isa_impl<foo,bar>(const bar &Val) {
  errs() << "Classof: " << &Val << "\n";
  return true;
}

La prueba se llama con un B y tiene:

if (!isa<foo>(B1)) return;
if (!isa<foo>(B2)) return;

Si entiendo lo que está pasando correctamente, el isa plantilla (que es utilizada por dyn_cast) utiliza la especialización explícita de isa_impl para vincular la barra con foo.En los ejemplos dados parece que isa<foo>(B1) devuelve verdadero!

De todos modos, este es un comportamiento muy diferente al de Dynamic_cast, por lo que realmente no creo que puedas compararlos entre sí.

Obviamente, es posible que no entienda bien lo que está haciendo LLVM, así que ¡avíseme si no he entendido el código!