Bizarre static_cast truco?

Question

mientras buscando el código fuente de Qt me encontré con esta joya:

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

Aviso del static_cast<T>(0)->Type? He estado usando C++ durante muchos años, pero nunca antes había visto 0 en una transmisión estática. ¿Qué está haciendo este código y es seguro?

Antecedentes: Si que se derivan de QGraphicsItem que están destinados a declarar un valor de enumeración único llamado Type que e implementar una función virtual llamada type que lo devuelve, por ejemplo:

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

A continuación, puede hacer esto:

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

Esto probablemente ayude a explicar lo que está tratando de hacer staticcast.

Answer 1

Esto parece ser una manera muy dudosa para afirmar de forma estática que el parámetro de plantilla T tiene un miembro Type, y luego verificar su valor es el número mágico era de esperar, como usted afirma que se supone que hacer.

Desde Type es un valor de enumeración, el puntero this no es necesaria para acceder a ella, por lo static_cast<Item>(0)->Type recupera el valor de Item::Type sin utilizar realmente el valor del puntero. Así que esto funciona, pero es posible que sea un comportamiento indefinido (dependiendo de su vista del estándar, pero IMO es una mala idea) porque el código elimina la referencia de un puntero NULL con el operador de desreferencia del puntero (->). Pero no puedo pensar por qué esto es mejor que solo Item::Type o la plantilla T::Type - tal vez es un código heredado diseñado para trabajar en compiladores antiguos con un soporte de plantilla deficiente que no podía resolver lo que se supone que significa T::Type.

Aún así, el resultado final es un código como qgraphicsitem_cast<bool>(ptr) se producirá un error en tiempo de compilación porque bool tiene ninguna enumeración Type miembro. Esto es más confiable y más barato que los controles de tiempo de ejecución, incluso si el código parece un truco.

Answer 2

Es un poco extraño, sí, y es un comportamiento oficialmente indefinido.

Tal vez podría haber escrito la siguiente manera (tenga en cuenta que T aquí no más es un puntero, si se trata de un puntero en el código original):

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

Pero ellos pueden haber sido mordido por constness, y obligado a escribir 2 versiones de la misma función. Tal vez una razón para la elección que hicieron.

Answer 3

El estándar actual y el borrador para el próximo estándar sugieren que eliminar referencias a un puntero nulo es un comportamiento indefinido (ver sección 1.9). Como a->b es un atajo para (*a).b, el código parece como si tratara de eliminar la referencia de un nullpointer. La pregunta interesante aquí es: ¿el static_cast<T>(0)->Type en realidad constituye una desreferencia de puntero nulo?

En el caso de que Type fuera un miembro de datos, esto definitivamente eliminaría la referencia de un nullpointer y, por lo tanto, invocaría un comportamiento indefinido. Pero de acuerdo con su código Type es solo un valor de enumeración y static_cast<T>(0)-> solo se usa para la búsqueda de nombre/scoping. En el mejor de los casos, este código es cuestionable.Me resulta irritante que se acceda a una "propiedad de tipo estático" como un valor de enum local a través del operador de flecha. Probablemente lo habría resuelto de manera diferente:

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

Answer 4

Este es un truco común para usar miembros protegidos (estáticos) de fuera de la (sub) clase. Una forma mejor habría sido exponer algún método, pero dado que no estaba destinado a ser una clase de usuario, ¡soltaron el trabajo duro!