Come devo fare questa specializzazione esplicita?

Question

sta seguendo la progettazione possibile:?

template <typename T>
class Test{
 public:
  template <typename Z>
  void doSomething();
  //rest of things
 private:
  T obj;
  //some things
};

Ora, se fosse possibile mi piacerebbe fare alcune specializzazioni esplicite per doSomething in modo che alla fine avrei alcune versioni come di seguito:

void doSomething<int>(){
 //do something
}
void doSomething<double>(){
 //do something
}
...etc

che sembra impossibile non riesco a trovare alcuna sintassi per fare il lavoro, allora ho pensato che forse il design dovrebbe essere come segue in modo che tutti gli argomenti di template devono essere passati al modello di classe stessa:

template <typename T,typename Z>
class Test{
 public:
  void doSomething();
  //rest of things
 private:
  T obj;
  //some things
};

Poi ho cercato di specializzazione parziale, che non ha nemmeno compilare:

template <typename T>
void Test<T,int>::doSomething(){
 //do something
}
template <typename T>
void Test<T,double>::doSomething(){
 //do something
}
...etc

ho ottenuto le seguenti errori per specializzazione esplicita:
Errore # 1: lista degli argomenti template seguente classe template nome deve parametri della lista nell'ordine utilizzato nella lista dei parametri del modello
. Errore # 2: 'Container1':. troppo pochi argomenti di template

Answer 1

Al fine di specializzarsi in modo esplicito doSomething si hanno anche per specializzarsi in modo esplicito Test.

Da 14.7.3 / 18:

  

In una specializzazione esplicita   dichiarazione per un membro di una classe   modello o un modello di membro che   appare in ambito spazio dei nomi, il membro   modello e alcuni dei suoi racchiude   modelli di classe possono rimanere   non specializzato, tranne che il   dichiarazione non esplicitamente   specializzarsi un modello di membro della classe, se   i suoi modelli di classi che racchiudono non sono   esplicitamente specializzata nonché .

Answer 2

Non è possibile specializzarsi in modo esplicito un modello di membro a meno che i suoi modelli di classi che racchiudono sono anche esplicitamente specializzati.

Quindi, solo qualcosa di simile a questo lavoro sarà:

template<> template<>
void Test<int>::doSomething<int>()
{
}

Answer 3

si può sempre fare la funzione inline

template <class T>
class Test
{
public:
 template <class Z>
 void doSomething() { cout << "default" << endl; }

 template<>
 void doSomething<int>() { cout << "int" << endl;}
 template<>
 void doSomething<double>() { cout << "double" << endl; }
private:
 T obj;
};

Answer 4

Credo che questo è schizzinosi. Suppongo che non si può fare, leggi questo .

Answer 5

Non sono sicuro se questo è un bug in g ++, ma questo compila e produrre ciò che mi aspetto.

#include<typeinfo>
#include<iostream>

template<typename T>
class Test
{
public:
    template<typename Z>
    void doSomething();

private:
    T obj;
};

template<typename T>
template<typename Z>
void Test<T>::doSomething()
{
    Z val;
    std::cout << __func__ << ": type " << typeid(val).name() << std::endl;
}

int main(int argc, char *argv[])
{
    Test<double> a;
    a.doSomething<int>();
    a.doSomething<double>();
}

Answer 6

icecrime postato una risposta temporanea e viene compilato a causa di qualche bug, probabilmente da C ++ visivo 2008:

template <typename T>
class Test{
 public:
  template <typename Z>
  void doSomething();
  //rest of things
 private:
  T obj;
  //some things
};
template <>
template <typename T>
void Test<T>::doSomething<int>(){
 //do something
}

Controlla la sua risposta corrente però. La cosa divertente almeno con VC ++ 2008 è, non è un problema quando la compilazione specializzata con le definizioni in linea, ma per le specializzazioni con definizioni non-inline una volta c'è più di una versione che non viene compilato con successo.