Passaggio passato tipo da modello

Question

E 'possibile in C++ verificare il tipo passato in una funzione modello? Per esempio:

template <typename T> 
void Foo() 
{ 
    if (typeof(SomeClass) == T) 
     ...; 
    else if (typeof(SomeClass2) == T) 
     ...; 
} 

Answer 1

Sì, è ... ma probabilmente non funzionerà come ti aspetti.

template < typename T > 
void foo() 
{ 
    if (is_same<T,SomeClass>::value) ...; 
    else if (is_same<T,SomeClass2>::value) ...; 
} 

È possibile ottenere is_same da std:: o boost:: a seconda del vostro desiderio/compilatore. Il primo è solo in C++ 0x.

Il problema si presenta con ciò che è in .... Se ti aspetti di essere in grado di fare una chiamata di funzione specifica a quei tipi in foo, ti stai sbagliando tristemente. Si verificherà un errore del compilatore anche se quella sezione di codice non viene mai eseguita quando si passa a qualcosa che non obbedisce all'interfaccia prevista.

Per risolvere QUEL problema è necessario fare qualcosa di leggermente diverso. Mi consiglia di dispacciamento tag:

struct v1_tag {}; 
struct v2_tag {}; 

template < typename T > struct someclass_version_tag; 
template < > struct someclass_version_tag<SomeClass> { typedef v1_tag type; }; 
template < > struct someclass_version_tag<SomeClass2> { typedef v2_tag type; }; 

void foo(v1_tag) { ... } 
void foo(v2_tag) { ... } 
template < typename T > void foo() 
{ 
    typedef typename someclass_version_tag<T>::type tag; 
    foo(tag()); 
} 

Nota che non sarà essere affetti alcun overhead runtime-polimorfismo qui e con le ottimizzazioni attivate esso dovrebbe comportare lo stesso o addirittura più piccola dimensione del codice e la velocità (anche se si shouldn' t preoccupiamoci comunque fino a quando non avrai eseguito un profiler).

Answer 2

Se si vuole fare qualcosa di specifico in base al tipo, si specializzano il modello:

template <typename T> 
void Foo() { } 

template <> 
void Foo<SomeClass>() { } 

template <> 
void Foo<SomeClass2>() { } 

// etc. 

(In realtà non desidera specializzarsi la funzione di modello, anche se, questo è solo per esposizione. potrete sia vuole sovraccaricare il modello, se è possibile, o delegare ad un modello di classe specializzato. per ulteriori informazioni su perché e come evitare specializzata modelli di funzione, leggere di Why Not Specialize Function Templates? Herb Sutter)

Answer 3

Sì. Dovrai usare type traits. Per esempio:

#include <boost/type_traits/is_same.hpp> 

template <typename T> 
void Foo() 
{ 
    if ((boost::is_same<T, SomeClass>::value)) 
     ...; 
    else if ((boost::is_same<T, SomeClass2>::value)) 
     ...; 
} 

seconda di cosa si sta cercando di ottenere, utilizzando template specialization potrebbe essere molto migliore scelta.

Inoltre, è possibile utilizzare enable_if/disable_if per abilitare/disabilitare determinate funzioni/metodi. La combinazione di questo con i tratti del tipo consentirà, ad esempio, di utilizzare una funzione per un insieme di tipi e un'altra funzione per un altro insieme di tipi.

Answer 4

No, ma è possibile utilizzare la specializzazione parziale:

template<typename T> 
struct Bar { static void foo(); }; 
template<typename T> 
template<> inline void Bar<T>::foo() { 
//generic 
} 
template<> inline void Bar<int>::foo() { 
//stuff for int 
} 
template<> inline void Bar<QString>::foo() { 
//QString 
} 

Modifica Sì con tratti di tipo, tuttavia non è realmente necessario. Modifica 2 tipo_traits esempio.

#include <type_traits> 
template<typename T> void foo() { 
    using std::is_same; 
    if<is_same<T, T2>::value || is_same<T, T1>::value) { 
     /* stuff */ 
    } 
}