Bizzarro trucco statico_cast?

Question

mentre sfogliando il codice sorgente di Qt mi sono imbattuto in questo gioiello:

template <class T> inline T qgraphicsitem_cast(const QGraphicsItem *item) 
{ 
    return int(static_cast<T>(0)->Type) == int(QGraphicsItem::Type) 
     || (item && int(static_cast<T>(0)->Type) == item->type()) ? static_cast<T>(item) : 0; 
} 

Avviso il static_cast<T>(0)->Type? Sto usando C++ da molti anni ma non ho mai visto 0 essere usato in un static_cast prima. Che cosa sta facendo questo codice ed è sicuro?

Background: Se derivare da QGraphicsItem che sono destinati a dichiarare un valore di enumerazione unico chiamato Type che e implementare una funzione virtuale chiamato type che restituisce, ad esempio:

class Item : public QGraphicsItem 
{ 
public: 
    enum { Type = MAGIC_NUMBER }; 
    int type() const { return Type; } 
    ... 
}; 

È quindi possibile fare questo:

QGraphicsItem* item = new Item; 
... 
Item* derivedItem = qgraphicsitem_cast<Item*>(item); 

Questo probabilmente aiuterà a spiegare cosa sta provando a fare questo static_cast.

Answer 1

Questo sembra un modo molto discutibile per affermare staticamente che il parametro modello T ha un membro Type e quindi verificare che il suo valore sia il numero magico previsto, come si afferma che si suppone di fare.

Da Type è un valore di enumerazione, il puntatore this non è necessario per accedervi, così static_cast<Item>(0)->Type recupera il valore di Item::Type senza utilizzare il valore del puntatore. Quindi funziona, ma forse è un comportamento indefinito (a seconda della visualizzazione dello standard, ma IMO è una cattiva idea in ogni caso), perché il codice dereferenzia un puntatore NULL con l'operatore di dereferenziazione puntatore (->). Ma non riesco a pensare perché questo sia migliore rispetto al solo Item::Type o al modello T::Type - forse è un codice legacy progettato per funzionare su vecchi compilatori con un supporto di template scadente che non riusciva a capire cosa intendeva dire T::Type.

Tuttavia, il risultato finale è un codice come qgraphicsitem_cast<bool>(ptr) fallirà al momento della compilazione perché bool non ha enum Type membro. Questo è più affidabile ed economico rispetto ai controlli di runtime, anche se il codice sembra un hack.

Answer 2

È un po 'strano, sì, ed è un comportamento ufficialmente indefinito.

forse potrebbero hanno scritto come segue (si noti che T qui non è più un puntatore, se si tratta di un puntatore nel codice originale):

template <class T> inline T * qgraphicsitem_cast(const QGraphicsItem *item) 
{ 
    return int(T::Type) == int(QGraphicsItem::Type) 
     || (item && int(T::Type) == item->type()) ? static_cast<T *>(item) : 0; 
} 

Ma essi possono essere stati morsi da constness, e costretto a scrivere 2 versioni della stessa funzione. Forse una ragione per la scelta che hanno fatto.

Answer 3

Lo standard corrente e la bozza dello standard imminente suggeriscono che il dereferenziamento di un puntatore nullo è un comportamento non definito (vedere la sezione 1.9). Dal a->b è una scorciatoia per (*a).b il codice sembra come prova a dereferenziare un punto nullo. La domanda interessante qui è: lo static_cast<T>(0)->Type costituisce effettivamente un dereferenziamento del puntatore nullo?

Nel caso Type era un membro di dati questo sarebbe sicuramente dereferenziare un nullpointer e quindi invocare il comportamento non definito. Ma secondo il tuo codice Type è solo un valore enum e static_cast<T>(0)-> viene utilizzato solo per la ricerca dell'ambito/nome. Nel migliore dei casi questo codice è discutibile.Trovo irritante che una "proprietà di tipo statico" come un valore enum locale sia accessibile tramite l'operatore della freccia. Probabilmente l'avrei risolto in modo diverso:

typedef typename remove_pointer<T>::type pointeeT; 
return … pointeeT::Type … ; 

Answer 4

Questo è un trucco comune per utilizzare membri (statici) protetti dall'esterno della (sotto) classe. Un modo migliore sarebbe stato quello di esporre qualche metodo, ma dal momento che non era destinato alla classe utente, lasciano andare il duro lavoro? !!