LLVM è un'eccezione alla regola per evitare cast dinamici?

Question

LLVM ha un'alternativa propria a quella di RTTI, che è un miglioramento della velocità rispetto a RTTI integrato e consente il casting dinamico in classi senza vtable (dyn_cast). Tuttavia, può ancora essere utilizzato esattamente come viene utilizzato dynamic_cast<> sebbene consenta di utilizzarlo con più classi.

dyn_cast<> documentazione del modello

LLVM è un rispettabile progetto C ++, quindi questo sembra volare di fronte al detto comune che troppi cast dinamici sono un segno di cattiva progettazione, noto anche come odore di codice. Sicuramente un cast dinamico dalle prestazioni migliori non fa nulla per migliorare il suo utilizzo nel design di uno standard dynamic_cast. Quindi chi è qui? Ci sono casi in cui l'uso su larga scala del casting dinamico è una buona scelta progettuale nel codice C ++? Google presenta 690 occorrenze di questo tipo di casting dinamico nel codice sorgente del trunk LLVM.

Usi di <=> nel trunk LLVM

Answer 1

Sebbene i risultati delle prestazioni siano un motivo per evitare dynamic_cast<> per le gerarchie di classi di grandi dimensioni, non è l'unico motivo per cui potresti volerli evitare. Migliori prestazioni o no, non si dovrebbe essere più incoraggiati a usare dyn_cast<> a causa di questa affermazione.

D'altra parte, non c'è assolutamente nulla di sbagliato nell'usare goto quando è lo strumento migliore per il lavoro. Se il suo uso è giustificato e il modo più pulito per risolvere un problema, allora è sempre giusto, indipendentemente dal & Quot; detto comune & Quot ;.

Non vorrei certo evitare progetti popolari semplicemente perché usano <=> s, <=> se qualsiasi altro linguaggio che è sfuggito al favore.

Answer 2

Penso che i cast di dinamiche non siano male perché sono lenti, ma perché implicano che il tuo codice sia troppo stretto.

Answer 3

Ho dato solo una rapida occhiata all'implementazione di dyn_cast e isa nella documentazione di LLVM.

L'esempio nel codice ha il seguente:

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

Il test viene chiamato con B e ha:

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

Se capisco cosa sta succedendo correttamente, il modello isa (che viene utilizzato da dyn_cast) utilizza la specializzazione esplicita di isa_impl per collegare la barra con foo. Negli esempi forniti sembra che isa<foo>(B1) ritorni vero!

Ad ogni modo, questo è un comportamento molto diverso da quello di dynamic_cast, quindi non credo davvero che tu possa confrontarli tra loro.

Ovviamente, potrei capire male cosa sta facendo LLVM, quindi per favore fatemi sapere se non ho capito il codice!