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

Question

LLVM tiene su propia alternativa enrollada a mano a RTTI que es una mejora de velocidad sobre RTTI incorporado y permite fundición dinámica a clases sin vtable (dyn_cast). Sin embargo, todavía se puede usar de la misma manera que se usa dynamic_cast<> aunque permite que se use con más clases.

dyn_cast<> template documentation

LLVM es un proyecto de buena reputación C++ por lo que esto parece ir en contra de lo común decir que demasiados moldes dinámica es un signo de un mal diseño, también conocido como un olor código. Sin duda, un elenco dinámico de mejor rendimiento no hace nada para mejorar su uso en el diseño que un estándar dynamic_cast. Entonces, ¿quién está aquí? ¿Hay casos en los que el uso a gran escala de fundición dinámica sea una buena opción de diseño en el código C++? Google presenta 690 ocurrencias de este tipo de conversión dinámica en el código fuente de troncales LLVM.

Uses of dyn_cast<> in LLVM trunk

Answer 1

Si bien los golpes de rendimiento son una razón para evitar dynamic_cast<> para jerarquías de clases grandes, no es la única razón por la que puede querer evitarlos. Mejor rendimiento o no, no se debe alentar más a usar dyn_cast<> debido a este reclamo.

Por otro lado, no hay nada de malo en usar dynamic_cast<> 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 del "dicho común".

No me alejaría de los proyectos populares simplemente porque usan dynamic_cast<> s, goto o cualquier otro idioma que haya caído en desgracia.

Answer 2

creo que la dinámica de los moldes son malas no porque son lentos, pero debido a que implica que su código es demasiado estrechamente unida.

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 exmaple en el código tiene el 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, la plantilla isa (que es utilizado 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) es verdadero!

De todos modos, este comportamiento es muy diferente al de dynamic_cast, así que realmente no creo que puedas compararlos entre sí.

Obviamente, puedo estar entendiendo mal lo que LLVM está haciendo, así que por favor avíseme si no he entendido el código.