Cómo especializar la plantilla para el tipo derivada del tipo particular

Question

Tengo la clase World que gestiona la creación del objeto ... Después de la creación, llama al método afterCreation y el objeto creado es de tipo definido por el usuario derivado de la entidad (por ejemplo MyEntity), Quiero llamar al addEntity. Yo el objeto era otra cosa, no quiero hacer nada. addEntity debe ser llamado con T adecuada, ya que genera identificadores únicos para cada clase derivada etc.

Aquí está mi solución:

template <int v> 
struct ToType 
{ 
    enum { value = v }; 
}; 

template <typename T> 
void World::afterCreation(T * t) 
{ 
    afterCreation(t, ToType<std::is_base_of<Entity, T>::value>()); 
} 

template <typename T> 
void World::afterCreation(T * t, ToType<true>) 
{ 
    addEntity(t); //here I cant pass Entity *, I need the real type, eg. MyEntity 
} 

template <typename T> 
void World::afterCreation(T * t, ToType<false>) 
{ 

} 

Mi pregunta es - ¿Puede hacerse en forma mejor?

¿Cómo puedo simular el código siguiente sin ToType o similar?

template <typename T> 
void afterCreation(){/*generic impl*/} 

template <typename T where T is derived from Entity> 
void afterCreation(){/*some specific stuff*/} 

• "especializan" en el título es sólo para describir mi intención, no hay necesidad de resolver un problema en esta especialización de plantilla

Answer 1

no va a hacer que sea mucho mejor, pero se puede quitar un nivel de indirección utilizando SFINAE:

template <typename T> 
typename std::enable_if< std::is_base_of<Entity, T>::value >::type 
World::afterCreation(T * t) 
{ 
    // Derived from Entity 
} 
template <typename T> 
typename std::enable_if< !std::is_base_of<Entity, T>::value >::type 
World::afterCreation(T * t) 
{ 
    // generic 
} 

¿Cómo funciona esto? Cuando el compilador encuentra la llamada al afterCreation, intenta determinar cuál de las sobrecargas es mejor, y para eso coincide con los tipos e intenta realizar la sustitución. En ambos casos, el tipo coincidente (de los argumentos) y aplicar la sustitución a la expresión completa. La plantilla enable_if contiene un tipo interno type si el valor pasado como primer argumento es true o si no contiene dicho tipo. Durante la sustitución de los tipos, una de las sobrecargas producirá una firma de función no válida (aquella para la que la condición es falsa) y se eliminará del conjunto de candidatos.

Answer 2

Usted puede hacer esto con los punteros polimórficas:

template <typename T> 
void afterCreation(T* x) { 
    T* entity = dynamic_cast<Entity*> x; 

    if (!entity) { 
     // ... generic implementation 
    } else { 
     // ... entity implementation, use "entity" 
    } 
} 

Aunque esta podría no ser la mejor solución, ya que tiene una sobrecarga de tiempo de ejecución (pequeña). Un compilador muy inteligente podría eliminar esta sobrecarga a través del análisis estático, pero dudo que los compiladores lo capten.