Est-ce que LLVM est une exception à la règle pour éviter les lancements dynamiques?

Question

LLVM dispose de sa propre alternative à la RTTI qui est une amélioration de la vitesse par rapport à la RTTI intégrée et qui permet la conversion dynamique en classes sans vtable (dyn_cast). Cependant, il peut toujours être utilisé exactement de la même façon que dynamic_cast<>, bien qu'il puisse être utilisé avec plus de classes.

projet

dyn_cast<> template documentation

LLVM est une bonne réputation C++ si cela semble voler dans le visage de la commune disant que trop de moulages dynamiques est un signe de mauvaise conception, aussi connu comme une odeur de code. Sûrement un casting dynamique plus performant ne fait rien pour améliorer son utilisation dans la conception qu'un standard dynamic_cast. Alors, qui est ici? Y a-t-il des cas où l'utilisation à grande échelle de la coulée dynamique est un bon choix de conception dans le code C++? Google affiche 690 occurrences de ce type de diffusion dynamique dans le code source du LLVM.

Uses of dyn_cast<> in LLVM trunk

Answer 1

Alors que les hits de performance sont une raison pour éviter dynamic_cast<> pour les hiérarchies de grande classe, ce n'est pas la seule raison pour laquelle vous pourriez vouloir les éviter. Plus performant ou non, il ne devrait pas être plus encouragé à utiliser dyn_cast<> à cause de cette affirmation. Par contre, il n'y a absolument rien de mal à utiliser dynamic_cast<> quand c'est le meilleur outil pour le travail. Si son utilisation est justifiée, et la façon la plus propre de résoudre un problème, alors c'est toujours juste, indépendamment du "dicton commun".

Je ne voudrais certainement pas éviter les projets populaires simplement parce qu'ils utilisent dynamic_cast<> s, goto s ou tout autre idiome qui est tombé en disgrâce.

Answer 2

Je pense que la dynamique des moulages sont mauvais non pas parce qu'ils sont lents, mais parce qu'ils impliquent que votre code est trop étroitement couplé.

Answer 3

J'ai seulement jeté un rapide coup d'œil sur l'implémentation de dyn_cast et isa dans la documentation LLVM.

Le exmaple dans le code les éléments suivants sont:

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

Le test est appelé avec un B et a:

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

Si je comprends ce qui se passe correctement, le modèle isa (qui est utilisé par dyn_cast) utilise la spécialisation explicite de isa_impl pour lier la barre avec foo. Dans les exemples donnés, il semble que isa<foo>(B1) retourne vrai!

Quoi qu'il en soit, c'est un comportement très différent de celui de dynamic_cast, donc je ne pense vraiment pas que vous pouvez les comparer les uns aux autres.

De toute évidence, je peux mal comprendre ce que fait LLVM, alors s'il vous plaît faites le moi savoir si je n'ai pas compris le code!