la specializzazione del modello con un tipo di templatized

Question

voglio specializzare un modello di classe con la seguente funzione:

template <typename T> 
class Foo 
{ 
public: 
    static int bar(); 
}; 

La funzione non ha argomenti e deve restituire un risultato in base al tipo di Foo. (In questo esempio giocattolo, torniamo il numero di byte del tipo, ma alla effettiva applicazione vogliamo tornare qualche oggetto meta-dati.) La specializzazione funziona per i tipi completamente specificati:

// specialization 1: works 
template <> 
int Foo<int>::bar() { return 4; } 

// specialization 2: works 
template <> 
int Foo<double>::bar() { return 8; } 

// specialization 3: works 
typedef pair<int, int> IntPair; 
template <> 
int Foo<IntPair>::bar() { return 2 * Foo<int>::bar(); } 

Tuttavia, Vorrei generalizzare questo ai tipi che dipendono da (altri) parametri del modello stessi. L'aggiunta dei seguenti specializzazione dà un errore di compilazione (VS2005):

// specialization 4: ERROR! 
template <> 
template <typename U, typename V> 
int Foo<std::pair<U, V> >::bar() { return Foo<U>::bar() + Foo<V>::bar(); } 

Io parto dal presupposto che non è legale C++, ma perché? E c'è un modo per implementare questo tipo di schema elegantemente?

Answer 1

specializzazione Partitial è valida solo per le classi, non funzioni.

Soluzione:

template <typename U, typename V> 
class Foo<std::pair<U, V> > { 
public: 
static int bar() { return Foo<U>::bar() + Foo<V>::bar(); } 
}; 

Se non si desidera specializzarsi pienamente classe, utilizzare struct ausiliario

template<class T> 
struct aux { 
    static int bar(); 
}; 

template <>int aux <int>::bar() { return 4; } 
template <>int aux <double>::bar() { return 8; } 

template <typename U, typename V> 
struct aux <std::pair<U, V> > { 
    static int bar() { return Foo<U>::bar() + Foo<V>::bar(); } 
}; 

template<class T> 
class Foo : aux<T> { 
    // ... 
}; 

Answer 2

È perfettamente legale in C++, è la specializzazione di modelli parziali.
Rimuovere il template <> e se non lo fa già esiste aggiungere l'esplicito modello di classe di specializzazione e dovrebbe compilare su VS2005 (ma non in VC6)

// explicit class template specialization 
template <typename U, typename V> 
class Foo<std::pair<U, V> > 
{ 
public: 
    static int bar(); 
}; 

template <typename U, typename V> 
int Foo<std::pair<U, V> >::bar() { return Foo<U>::bar() + Foo<V>::bar(); }