Specjalizacja szablonu dla statycznych funkcji składowych; jak?

Question

Próbuję zaimplementować funkcję szablonu z uchwytami unieważniającymi inaczej przy użyciu specjalizacji szablonu.

Poniższy kod daje mi „Explicit specjalizacji w zakresie non-namespace” w 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(); 
    } 
} 

Próbowałem przesuwając go z klasy (klasa nie jest na matrycy) oraz w przestrzeni nazw, ale wtedy pojawia się błąd "Wyraźna specjalizacja nie może mieć klasy pamięci". Czytałem wiele dyskusji na ten temat, ale ludzie nie zgadzają się, jak specjalizować szablony funkcji. Jakieś pomysły?

Answer 1

Kiedy specjalizują metodę szablonie, należy to zrobić poza nawiasami klasy:

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' 
} 

Jeśli wziąć ją na zewnątrz klasy, trzeba usunąć słowo kluczowe "statyczne". Statyczne słowo kluczowe poza klasą ma określone znaczenie inne niż prawdopodobnie.

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

Można zadeklarować wyraźnej specjalizacji w taki sam sposób chcesz zdefiniować funkcję składową poza jego klasę:

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

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

Answer 3

Twój problem wydaje się być z boost :: funkcji - następujące specjalizacje pracy:

Answer 4

to nie bezpośrednio odpowiedzi na swoje pytanie, ale można napisać ten

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

Powinno działać, nawet jeśli _f() zwróci 'void'

Edycja: w bardziej ogólnym przypadku, myślę, że powinniśmy preferować przeciążanie funkcji zamiast specjalizacji. Tutaj jest dobrym wyjaśnieniem tego: http://www.gotw.ca/publications/mill17.htm

Answer 5

Miałem podobny problem. Jeśli spojrzysz na oryginalny post, zostawiłem pierwsze statyczne, ale wyjąłem drugie i zniknęły BOTH.