Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > Heterogeneous containers with CRTP

Reply
Thread Tools

Heterogeneous containers with CRTP

 
 
Arash Partow
Guest
Posts: n/a
 
      05-14-2007
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)-
>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

 
Reply With Quote
 
 
 
 
Salt_Peter
Guest
Posts: n/a
 
      05-15-2007
On May 14, 7:10 pm, Arash Partow <(E-Mail Removed)> wrote:
> 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
crtp_base<crtp_b>.

>
> 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



 
Reply With Quote
 
 
 
 
Axter
Guest
Posts: n/a
 
      05-15-2007
On May 14, 7:10 pm, Arash Partow <(E-Mail Removed)> wrote:
> 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)-
>
> >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


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

 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Are sequence containers not a subset of general containers? Sebastian Mach C++ 5 10-06-2012 07:54 PM
Containers of iterators vs. containers of references clark.coleman@att.net C++ 7 01-25-2008 01:37 PM
Number hierarchically across heterogeneous elements Mike XML 3 07-07-2005 06:40 PM
Validating heterogeneous XML kj XML 1 04-15-2004 06:57 PM
Heterogeneous linked structures; for a Tire search. Jason C++ 0 08-21-2003 08:03 PM



Advertisments