Memberfunktionen spezialisieren

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...

wxSkip

ttttt schrieb:

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.

wxSkip

ttttt schrieb:

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)
{
    //...
}

Sowas wird nicht gelinkt (undefined reference), wenn der zweite Codeschnipsel in einer .cpp-Datei steht:

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.

wxSkip

Hm, GCC gibt keinen Error aus, nur Warnungen wegen mehrfacher Deklaration. Hab jetzt aber auch nur eine C++-Datei.
Wenn die Spezialisierung im Header nicht deklariert wird, kann sie aber nur in einer Datei verwendet werden.

Kann(Muss) man sie nun im Header deklarieren oder nicht? Wenn ja, wie? (standardkonform)

wxSkip

Das weiß ich nicht. Sieht aber nach den GCC-Warnungen nicht so aus.

wxSkip

Moment mal: Warum machst du das nicht einfach anders?

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.

Weil das vom Verhalten für den Nutzer der Klasse völlig anders ist... Ich möchte in diesem Fall z.B. eine Instanz der Klasse erzeugen, auf die alle verschiedenen Spezialisierungen der Memberfunktion angewendet werden können.