ich weiß, dass Templatespezialisierung nicht greifen, wenn man nicht die angegebene Klasse sondern eine abgeleitete Klasse als Template-Parameter angibt.
Gibt es dennoch eine Möglichkeit ein Verhalten zu verwirklichen, wo es auch für abgeleitete Klassen greift?

#include <vector>
#include <iostream>

class Foo{};

class Bar : public Foo{};

template<typename T>
class FooBar{
public:
        void foobar(){
                std::cout << "default" << std::endl;
        }
};

template<>
class FooBar<Foo>{
public:
        void foobar(){
                std::cout << "Foo" << std::endl;
        }
};

int main(){
        FooBar<Foo> foo;
        foo.foobar();
        FooBar<Bar> bar;
        bar.foobar();
}

Ich hoffe ihr wisst, was ich meine.
Also bei bar.foobar(); hätte ich gerne "Foo" als Ausgabe.

Gruß,
XSpille

Du kannst es so machen, wie die STL mit den Iteratoren.

Ich verstehe absolut nicht, was du meinst...

CStoll schrieb:

Irgendwo in der Boost-Library bzw. TR1 gibt es doch ein derived_of<>-Template, eventuell könntest du damit etwas basteln.

Ich werd mal kucken, ob ich damit etwas basteln kann.

thx

EDIT: Du meinst "is_base_of", oder?
www.boost.org/doc/libs/1_46_1/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html

EDIT: Du meinst "is_base_of", oder?
www.boost.org/doc/libs/1_46_1/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html

Jup. Wenn du einen zweiten Temaplte-Parameter mit is_base_of default-belegst, brauchst du an deinem Beispielcode kaum was ändern:

#include <vector>
#include <iostream>
#include <boost/type_traits/is_base_of.hpp>

class Foo{};

class Bar : public Foo{};

template<typename T, typename is_base_t = typename boost::is_base_of<Foo, T>::type >
class FooBar{
public:
        void foobar(){
                std::cout << "default" << std::endl;
        }
};

template<typename T>
class FooBar<T, boost::true_type>{
public:
        void foobar(){
                std::cout << "Foo or derived" << std::endl;
        }
};

int main(){
        FooBar<Foo> foo;
        foo.foobar();
        FooBar<Bar> bar;
        bar.foobar();
        FooBar<int> fbi;
        fbi.foobar();
}

Output:

Foo or derived
Foo or derived
default

Sauber