class Foo {
public:
    template<typename T>
    T& Bar(char c) {/*...*/}

    template<>
    double& Bar<double>(char c) {/*...*/}

    template<>
    int& Bar<int>(char c) {/*...*/}
};

Ich meine gehört zu haben, dass es nicht standardkonform sei. MSVC schluckts, aber GCC?

class Foo {
public:
    template<typename T>
    T& Bar(char c) {/*...*/}
};

template<>
double& Foo::Bar<double>(char c) {/*...*/}

template<>
int& Foo::Bar<int>(char c) {/*...*/}

Wusste garnicht, dass das (zumindest unter MSVC) geht...

Du meinst sowas?

class Foo {
public:
    template<typename T>
    T& Bar(char c) {/*...*/}
};

template<>
double& Foo::Bar<double>(char c) {/*...*/}

template<>
int& Foo::Bar<int>(char c) {/*...*/}

Wusste garnicht, dass das (zumindest unter MSVC) geht...

Ja, das meinte ich. Du solltest die Implementation dieser Spezialisierungen sogar in die C++-Datei auslagern, weil sie nicht mehr von einem Template-Parameter abhängig sind und daher nicht static gemacht werden.

Unter MSVC kann man diese Spezialisierungen in der Klasse deklarieren. Dann erlaubt der Linker es allerdings nicht, diese Spezialisierungen in der Sourcedatei zu definieren.
Aber egal - Diese Deklaration ist ja (komischerweise, finde ich, das müsste bei dlls/shared objects doch problematisch werden, oder?) anscheinend garnicht notwendig.

Das musst du genauer erklären.

Das sollte der MSVC aber kompilieren, oder? (nicht getestet, Leichtsinnsfehler nicht ausgeschlossen):

//Header

template<typename T> class Foo
{
public:
    T Bar(char c);
}

template<> double Foo<double>::Bar(char c);

//C++-Datei
template<> double Foo<double>::Bar(char c)
{
    //...
}

class Foo {
    template<typename T>
    T& Bar();
    template<>
    double Bar<double>();
};

template<>
double Foo::Bar<double>() {return(0.1);}

D.h. die Spezialisierung darf nicht deklariert werden.

template<typename T> class FooBase {...};

template<typename T> class Foo : public FooBase<T>
{
public:
    T Bar(char c){...}
};

template<> class Foo<double> : public FooBase<double>
{
public:
    double Bar(char c){...}
};

In C++0x geht vielleicht auch meine alte Lösung mit

extern template<> double Foo<double>::Bar();

bei der Deklaration.