Heterogeneous containers with CRTP

[Arash Partow]

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
{

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

 

[Salt_Peter]

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.

You can't since anything derived from crtp_base<crtp_a> is_not_a

 

[Axter]

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
{

};

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

Either you need to have a common base class, or you need to have types
that have a common interface.

See following example for Heterogeneous Containers that can store
objects that have different base types, but have some type of common
interface (function signature).

http://code.axter.com/HeterogeneousContainer1.cpp
http://code.axter.com/HeterogeneousContainer2.cpp
http://code.axter.com/HeterogeneousContainer3.cpp