Template specialisation for templated base class

Hi all,
I have a template that I want to specialise for a specific class and it's sub classes i.e.

Code:

---

template <typename T>
class MyTemplate
{
public:
    static void DoStuff(void)
    {
        cout << "generic template" << endl;
    }
};

class Base
{
};

class Derived : public Base
{
};

template <>
class MyTemplate<Base>
{
public:
    static void DoStuff(void)
    {
        cout << "base template" << endl;
    }
};

int main()
{
        MyTemplate<int>::DoStuff();        // OK - prints "generic template"
        MyTemplate<Base>::DoStuff();    // OK - prints "base template"

        MyTemplate<Derived>::DoStuff(); // BAH! - prints "generic template"
}

---

anyone have any ideas? If I can solve this than I'll worry about the next problem (Base is also a template!!)

Code:

---

        MyTemplate<int>::DoStuff();        // OK - prints "generic template"
        MyTemplate<Base>::DoStuff();    // OK - prints "base template"

        MyTemplate<Derived>::DoStuff(); // BAH! - prints "generic template"

---

you have not specialized the template for Derived so it uses the generic function.
Kurt

Boost's enable_if plus is_base_and_derived from Boost.Type_Traits can sort of accomplish what you want. But it's not as simple as just specializing the class.

Quote:

---

Originally Posted by ZuK

Code:

---

        MyTemplate<int>::DoStuff();        // OK - prints "generic template"
        MyTemplate<Base>::DoStuff();    // OK - prints "base template"

        MyTemplate<Derived>::DoStuff(); // BAH! - prints "generic template"

---

you have not specialized the template for Derived so it uses the generic function.
Kurt

---

I know WHY it doesn't work! I'm trying to find a way around it! :)

CornedBee, I thought about is_base_of but couldn't figure out a way to get it to work, but enable_if looks promising. I'll give it a shot, cheers!

Sorry. I should read your posts more carefully. Didn't see the "and it's sub classes"
Kurt

ok I tried CornedBee's idea and it works!

Code:

---

#include <boost/type_traits.hpp>
#include <boost/utility.hpp>
#include <boost/mpl/or.hpp>

template <typename T, typename Enable = void>
class MyTemplate
{
public:
    static void DoStuff(void)
    {
        cout << "generic template" << endl;
    }
};

class Base
{
};

class Derived : public Base
{
};

template <typename T>
class MyTemplate<T,
                                          typename boost::enable_if<
                                                        boost::mpl::or_<
                                                                boost::is_base_of<Base, T>,
                                                                boost::is_same<Base, T>
                                                        >
                                                >::type>
{
public:
    static void DoStuff(void)
    {
        cout << "base template" << endl;
    }
};

int main()
{
        MyTemplate<int>::DoStuff();        // OK - prints "generic template"
        MyTemplate<Base>::DoStuff();    // OK - prints "base template"

        MyTemplate<Derived>::DoStuff(); // Woohoo! - prints "base template"
}

---

god, I love boost! now I just need to figure out how to make it work with a templated Base class...

havent worked with this type of stuff in a while, but would 'virtual' help at all here?

No, doesn't have anything to do with the issue.


ChaosEngine, what exactly do you mean by templated base class? That there is a template parameter which names the type on which special handling is taken? I think you'll need a metafunction for that.

Quote:

---

Originally Posted by CornedBee

No, doesn't have anything to do with the issue.


ChaosEngine, what exactly do you mean by templated base class? That there is a template parameter which names the type on which special handling is taken?

---

not quite. It's a bit of an abuse of the type system really.

if we have a class hierarchy like this

Code:

---

template <typename T>
class Base
{
};

class D1 : public Base<short>
{
};

class D2 : public Base<int>
{
};

---

D1 and D2 have no inheritance relationship as Base<int> and Base<short> are essentially 2 different classes. I've actually soved it using a private "grandfather" class

Code:

---

template <typename T, typename U = void, typename Enable = void>
class MyTemplate
{
public:
    static void DoStuff(void)
    {
                cout << "generic template: " << typeid(T).name() << endl;
    }
};


class BaseBase {};

template <typename T>
class Base : private BaseBase
{
};

class Derived : public Base<short>
{
};

class D2 : public Base<int>
{
};

template <typename T>
class MyTemplate<T,
                              typename boost::enable_if<boost::is_base_of<BaseBase, T> >::type
                            >
{
public:
    static void DoStuff(void)
    {
                cout << "base template: " << typeid(T).name() << endl;
    }
};

int main()
{
        MyTemplate<int>::DoStuff();    // OK - prints "generic template"
        MyTemplate<Base<int> >::DoStuff();    // OK - prints "base template"

        MyTemplate<Derived>::DoStuff(); // Woohoo! - prints "base template"
        MyTemplate<D2>::DoStuff(); // Woohoo! - prints "base template"
}

---

it's a bit of a hack, but it works.

all this work is actually to define a metafunction to handle specialised Scalar math, but it works now. Thanks everyone, especially CornedBee.