Alternative zu Spezialisierung von Member-Funktions-Template

XSpille

Hallo zusammen,

ich kann ja bei Funktions-Templates eine Spezialisierung definieren.

Krieg ich ein ähnliches Verhalten auch bei Member-Funktionen hin?

#include<iostream>

class Bar{
public:
        template<int i>
        void func(){
                std::cout << i << std::endl;
        }

        template<>
        void func<1>(){}
};

int main(){
        Bar bar;
        bar.func<1>();
        bar.func<2>();
}

test.cpp:43:11: error: explicit specialization in non-namespace scope 'class Bar'
test.cpp:44:15: error: template-id 'func<1>' in declaration of primary template

Also so scheint es ja nicht zu gehen, aber gibt es einen Workaround?
Also generell experimentier ich ein bisschen mit variadic templates rum, wo es mir hilfreich erscheint.

Gruß,
XSpille

XSpille

argh...

Man kann auch einfach an eine Nicht-Member-Funktion delegieren und
dort die Fallunterscheidung machen

EDIT:
Gut, dass ich es nichtmal brauche ^^

krümelkacker

Geht eigentlich...

#include<iostream>

class Bar {
public:
        template<int i>
        void func(){
                std::cout << i << std::endl;
        }
};

template<>
void Bar::func<1>(){}

int main(){
        Bar bar;
        bar.func<1>();
        bar.func<2>();
}

...aber das Spezialisieren von Funktionstemplates ist böse.

XSpille

krümelkacker schrieb:

Geht eigentlich...

#include<iostream>

class Bar {
public:
        template<int i>
        void func(){
                std::cout << i << std::endl;
        }
};

template<>
void Bar::func<1>(){}

int main(){
        Bar bar;
        bar.func<1>();
        bar.func<2>();
}

...aber das Spezialisieren von Funktionstemplates ist böse.

Danke krümelkacker!
Genau den Artikel hatte ich vorher schon gesehen, aber man will ja trotzdem mal was testen

und wie krieg ich es hin, wenn ich zudem eine Template-Klasse habe:

#include<iostream>

template<typename T>
class Bar {
public:
        template<int i>
        void func(){
                std::cout << i << std::endl;
        }
};

template<typename T>
template<>
void Bar<T>::func<1>(){}

int main(){
        Bar<int> bar;
        bar.func<1>();
        bar.func<2>();
}

test.cpp:14:10: error: invalid explicit specialization before '>' token
test.cpp:14:10: error: enclosing class templates are not explicitly specialized
test.cpp:15:6: error: template-id 'func<1>' for 'void Bar<T>::func()' does not match any template declaration

Also wenn ich typename hier auf z.B. zusätzlich auf int festlege, funkt es.

template<>
template<>
void Bar<int>::func<1>(){}

Aber ich würde gerne das typename T behalten...

GorbGorb

Du kannst ein member template einer template Klasse nur dann explizit spezialisieren, wenn auch die Klasse explizit spezialisiert ist (ich meine aber, dass man das in vc++10 nicht machen muss)

XSpille

GorbGorb schrieb:

Du kannst ein member template einer template Klasse nur dann explizit spezialisieren, wenn auch die Klasse explizit spezialisiert ist (ich meine aber, dass man das in vc++10 nicht machen muss)

Sowas hatte ich fast schon erwartet.

Danke GorbGorb

Nexus

Nimm statt Spezialisierung Überladung und verwende den Trick, den ich dir letztes Mal gezeigt habe.

XSpille

Nexus schrieb:

Nimm statt Spezialisierung Überladung und verwende den Trick, den ich dir letztes Mal gezeigt habe.

So gehts natürlich auch
Manchmal denkt man einfach zu kompliziert oder will krampfhaft kucken, was alles möglich ist

Danke für den Hinweis!

Nexus

Vermeide einfach Funktionstemplate-Spezialisierung, mit Überladung bist du immer flexibler. Manchmal musst du dafür eine etwas unschönere Aufrufsyntax in Kauf nehmen.