Come specializzare template per tipo derivato dal particolare tipo

Question

Ho classe World che gestisce la creazione dell'oggetto ... Dopo la creazione chiama il metodo afterCreation e I l'oggetto creato è un tipo definito dall'utente derivato dall'entità (ad esempio MyEntity), Voglio chiamare addEntity. Io l'oggetto era qualcos'altro, non voglio fare niente. addEntity deve essere richiamato con adeguata T, perché genera ID univoci per ogni classe derivata ecc

Ecco la mia soluzione:

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>) 
{ 

} 

La mia domanda è - può essere fatto in modo migliore?

Come posso simulare il seguente codice senza ToType o simile?

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

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

• "specializzati" nel titolo è solo quello di descrivere la mia intenzione, non c'è bisogno di risolvere il problema con il modello di specializzazione

Answer 1

Non sta andando a fare molto meglio, ma è possibile rimuovere un livello di indirezione utilizzando 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 
} 

Come funziona? Quando il compilatore trova la chiamata a afterCreation prova a determinare quale dei sovraccarichi è migliore, e per quello corrisponde ai tipi e tenta di eseguire la sostituzione. In entrambi i casi, il tipo corrispondente (dagli argomenti) e applica la sostituzione all'intera espressione. Il modello enable_if contiene un tipo interno type se il valore passato come primo argomento è true oppure non contiene tale tipo. Durante la sostituzione dei tipi, uno dei sovraccarichi produrrà una firma di funzione non valida (quella per cui la condizione è falsa) e verrà eliminata dall'insieme di candidati.

Answer 2

Si può fare questo con i puntatori polimorfici:

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

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

Anche se questo potrebbe non essere la soluzione migliore poiché questo ha un (piccolo) sovraccarico di runtime. Un compilatore molto intelligente potrebbe rimuovere questo sovraccarico attraverso l'analisi statica, ma dubito che i compilatori lo prenderanno in considerazione.