Heterogeneous containers with CRTP

Hi all,

I've got a question related to emulating aspects of polymorphism
with CRTP. Below is a typical polymorphic class hierarchy with
a definition of a "somewhat" heterogeneous container of objects.

class poly_base
{
public: virtual int foo(int i, int j) = 0;
};

class poly_a : public poly_base
{
public: int foo(int i, int j) { return i + j; }
};

class poly_b : public poly_base
{
public: int foo(int i, int j) { return i * j; }
};

int boo(poly_base* p, int i, int j)
{
   return p->foo(i,j);
}

int main()
{
   poly_a a;
   poly_b b;
   poly_base* pa = &a;
   poly_base* pb = &b;

   std::vector<poly_base*> plist;
   plist.push_back(pa);
   plist.push_back(pb);

   int v = 0;
   for(std::vector<poly_base*>::iterator it = plist.begin();
       it != plist.end();
       ++it)
   {
      v += boo((*it),10,20);
   }
   return 0;
}

I was wondering how would one go about defining a container
of crtp_base's similar to the definition of the vector above
using the below structures.

Is it even possible without using an interface that is abstract?

template <typename T>
class crtp_base
{
public: int foo(int i, int j) { return static_cast<T*>(this)-


};

class crtp_a : public crtp_base<crtp_a>
{
public: int foo(int i, int j) { return i + j; }
};

class crtp_b : public crtp_base<crtp_b>
{
public: int foo(int i, int j) { return i * j; }
};

template<typename T>
int boo(crtp_base<T>* p, int i, int j)
{
   return p->foo(i,j);
}

int main()
{
   crtp_a a;
   crtp_b b;
   crtp_base<crtp_a>* pa = &a;
   crtp_base<crtp_b>* pb = &b;
   boo(pa,10,20);
   boo(pb,10,20);
   return 0;
}

Any help would be much appreciated.

Arash Partow
__________________________________________________
Be one who knows what they don't know,
Instead of being one who knows not what they don't know,
Thinking they know everything about all things.
http://www.partow.net