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)-
>foo(i,j); }};
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
