LLVM est-il une exception à la règle pour éviter les conversions dynamiques?

Question

LLVM a sa propre alternative au RTTI, ce qui représente une amélioration de la vitesse par rapport au RTTI intégré et permet le transtockage dynamique vers des classes sans vtable (dyn_cast). Cependant, il peut toujours être utilisé exactement de la même manière que dynamic_cast<> bien qu'il permette de l'utiliser avec plus de classes.

dyn_cast<> documentation sur les modèles

LLVM étant un projet C ++ réputé, cela semble aller à l’encontre du dicton général qui dit que trop de conversions dynamiques est un signe de mauvaise conception, également appelé odeur de code. Assurément, une distribution dynamique plus performante n'améliore pas son utilisation en conception par rapport à une norme dynamic_cast. Alors qui est ici? Existe-t-il des cas où l'utilisation à grande échelle de la diffusion dynamique constitue un bon choix de conception en code C ++? Google retourne 690 occurrences de ce type de diffusion dynamique dans le code source du tronc LLVM.

Utilisations de <=> dans le tronc LLVM

Answer 1

Bien que les résultats en termes de performances soient une raison d'éviter dynamic_cast<> pour les hiérarchies de classes volumineuses, ce n'est pas la seule raison pour laquelle vous pourriez vouloir les éviter. Mieux performant ou non, il ne faut pas être plus encouragé à utiliser dyn_cast<> à cause de cette affirmation.

D'un autre côté, il n'y a absolument rien de mal à utiliser goto quand c'est le meilleur outil pour le travail. Si son utilisation est justifiée et constitue le moyen le plus propre de résoudre un problème, elle a toujours raison, quel que soit le & Quot; dire commun & ";.

Je ne m'écarterais certainement pas des projets populaires simplement parce qu'ils utilisent <=> s, <=> s ou tout autre idiotisme qui est tombé en disgrâce.

Answer 2

Je pense que les conversions dynamiques sont mauvaises, non pas parce qu'elles sont lentes, mais parce qu'elles impliquent que votre code est trop étroitement lié.

Answer 3

Je n’ai que très rapidement examiné l’implémentation de dyn_cast et d’isa dans la documentation de LLVM.

L'exemple dans le code a les caractéristiques suivantes:

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 bien ce qui se passe, le modèle isa (utilisé par dyn_cast) utilise la spécialisation explicite de isa_impl pour relier la barre à foo. Dans les exemples donnés, il semble que isa<foo>(B1) retourne la valeur true!

Quoi qu’il en soit, ce comportement est très différent de celui de dynamic_cast, je ne pense donc pas que vous puissiez les comparer.

De toute évidence, je ne comprends peut-être pas ce que fait LLVM, alors faites-le moi savoir si je n'ai pas compris le code!