Re: polymorphism on template parameters

Renato Golin <rengolin@gmail.com> wrote in
news:48984b94$0$639$da29aeef@newsread.sanger.ac.uk:


Sadly, that is both the curse and blessing of policy based design.
Different template parameters create completely new types. The template
name itself doesn't imply interaction capability between the instances.
That is one of the reasons that shared_ptr<> in TR1 isn't a policy based
smart pointer.

I have two suggestions as to how to organize things to get around this
feature of templates.

First, Instead of policies, you can use strategies that get
configured/set by the constructor. In other words, don't use templates
in this way if you want the resulting types to interact as if they were
the same type.

Or, you can define an interface for the basic 'Thing'-ness and make all
your templated classes inherit from that and only use the template for
construction. i.e.

class IThing
{
   public:
   virtual void DoThing() = 0;
   virtual ~IThing() {}
};

class MovePolicy { };
class EatPolicy { };
class ReproducePolicy { };

template <
     class Move = MovePolicy,
     class Eat = EatPolicy,
     class Reproduce = ReproducePolicy

class Thing : public IThing, Move, Eat, Reproduce
{
public:
     Thing() { }
     virtual ~Thing() { }
     virtual DoThing() {}
};

class NoMove : public MovePolicy { };
class NoEat : public EatPolicy { };
class NoReproduce : public ReproducePolicy { };

class Stone : public Thing <NoMove, NoEat, NoReproduce>
{
public:
     Stone() { }
     ~Stone() { }
};

int
main () {
     IThing * s = static_cast<IThing *>(new Stone());
     s ->DoThing();
     delete s; // virtual destructor lets this work
     return 0;
}

HTH,
joe