per funzioni membro statiche; come?

Question

Sto tentando di implementare una funzione di modello con le maniglie vuote in modo diverso utilizzando la specializzazione del modello.

Il seguente codice mi dà una "specializzazione esplicita in ambito non-spazio dei nomi" in gcc:

template <typename T> 
static T safeGuiCall(boost::function<T()> _f) 
{ 
    if (_f.empty()) 
     throw GuiException("Function pointer empty"); 
    { 
     ThreadGuard g; 
     T ret = _f(); 
     return ret; 
    } 
} 

// template specialization for functions wit no return value 
template <> 
static void safeGuiCall<void>(boost::function<void()> _f) 
{ 
    if (_f.empty()) 
     throw GuiException("Function pointer empty"); 
    { 
     ThreadGuard g; 
     _f(); 
    } 
} 

ho provato a spostare fuori della classe (la classe non è templato) e nello spazio dei nomi, ma quindi viene visualizzato l'errore "La specializzazione esplicita non può avere una classe di archiviazione". Ho letto molte discussioni a riguardo, ma le persone non sembrano concordare su come specializzare i modelli di funzione. Qualche idea?

Answer 1

Quando si specializzano un metodo basato su modelli, è necessario farlo al di fuori delle fasce di classe:

template <typename X> struct Test {}; // to simulate type dependency 

struct X // class declaration: only generic 
{ 
    template <typename T> 
    static void f(Test<T>); 
}; 

// template definition: 
template <typename T> 
void X::f(Test<T>) { 
    std::cout << "generic" << std::endl; 
} 
template <> 
inline void X::f<void>(Test<void>) { 
    std::cout << "specific" << std::endl; 
} 

int main() 
{ 
    Test<int> ti; 
    Test<void> tv; 
    X::f(ti); // prints 'generic' 
    X::f(tv); // prints 'specific' 
} 

Quando si prende fuori della classe, è necessario rimuovere le parola chiave 'statica'. La parola chiave statica al di fuori della classe ha un significato specifico diverso da quello che probabilmente desideri.

template <typename X> struct Test {}; // to simulate type dependency 

template <typename T> 
void f(Test<T>) { 
    std::cout << "generic" << std::endl; 
} 
template <> 
void f<void>(Test<void>) { 
    std::cout << "specific" << std::endl; 
} 

int main() 
{ 
    Test<int> ti; 
    Test<void> tv; 
    f(ti); // prints 'generic' 
    f(tv); // prints 'specific' 
} 

Answer 2

È possibile dichiarare la specializzazione esplicita nello stesso modo che ci si definisce una funzione di membro al di fuori della sua classe:

class A 
{ 
public: 
    template <typename T> 
    static void foo() {} 
}; 

template <> 
void A::foo<void>() 
{ 
} 

Answer 3

Il tuo problema sembra essere con la funzione boost :: - le seguenti specializzazioni funzionano:

Answer 4

non è direttamente una risposta alla tua domanda, ma si può scrivere questo

template <typename T> 
static T safeGuiCall(boost::function<T()> _f) 
{ 
     if (_f.empty()) 
       throw GuiException("Function pointer empty"); 
     { 
       ThreadGuard g; 
       return _f(); 
     } 
} 

Dovrebbe funzionare anche se _f() restituisce 'void'

Modifica: In un caso più generale, penso che dovremmo preferire l'overloading delle funzioni anziché la specializzazione. Ecco una buona spiegazione per questo: http://www.gotw.ca/publications/mill17.htm

Answer 5

Ho avuto un problema simile. Se guardi il post originale, ho lasciato la prima statica, ma ho eliminato il secondo e ENTRAMBI gli errori sono andati via.