Sintassi per modelli di funzioni specializzate

Question

C'è una differenza tra i seguenti approcci?

// approach 1 
namespace std 
{ 
    template<> 
    void swap<Foo>(Foo& x, Foo& y) // note the <Foo> 
    { 
     x.swap(y); 
    } 
} 

// approach 2 
namespace std 
{ 
    template<> 
    void swap(Foo& x, Foo& y) 
    { 
     x.swap(y); 
    } 
} 

ho stumpled su questo quando ho provato a specializzarsi swap per il mio tipo di stringa e ho notato che swap<::string> non funziona, ma per un motivo completamente diverso :)

Answer 1

sì, c'è. Ma non in quel particolare esempio. Se il parametro non viene dedotta, può fare la differenza

template<typename T> void f(typename T::type t); 

Non si può specializzare che senza <type> perché non può dedurre cosa T da lista dei parametri.

struct MyType { typedef int type; }; 

// needs <MyType> 
template<> void f<MyType>(int t) { } 

Naturalmente nel tuo caso, è il digramma <: che ha senso la stessa [ causando il problema. Metti uno spazio come <   ::string> per evitare il problema.

Answer 2

Inoltre, non è necessario specializzarsi in questo caso, basta sovraccaricare ed essere felici.

namespace std 
{ 
    void swap(Foo& x, Foo& y) 
    { 
     x.swap(y); 
    } 
}