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.

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.

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.