Solving a template/struct issue

[Alexander Adam]

Hi!

I've got this issue: I have a struct like this:

struct node
{
unsigned int m_code;
?? m_data;
unsigned int m_data_size;
};

Which is put into a list like std::list<node> myList;

Now the issue is with m_data. I want a general approach to store
anything into m_data no matter what it is. It could be a list of
simple chars, unsigned ints or double or float or whatever. My idea
was that I could create an array for m_data, filling it up with the
appropriate values but how'd I go about this?
Lets take a basic sample -- Let's say I want to store those values
into my m_data (each into one single struct):

double dv = 1.8464634...;
double* dv2 = new double[3];
dv2[0] = dv;
dv2[1] = dv;
dv2[2] = dv;
const char* cv = "Hello World...";

How can I store dv, cv and especially dv2 correctly into my m_data
field without wasting memory and without having to templatize the node
struct?

And the next question of course is -- how can I correctly read back
those values into my variables with the best perfomance possible?

Could anyone provide me some simple sample code or give some hints on
how to go about this? I've thought about creating an array of e.g.
unsigned char and pushing the data into it. Would that work? If yes,
how would that look like?


Btw, just something I care for interest -- why will std::list<node*>
take much more memory than std::list<node> that is, when manually
doing a new node(); -> list.push_back(pointer_to_node) it takes more
memory at all than when using a value of std::list<node>?


Thanks a lot for any answer,
Regards
Alexander

 

[Lionel B]

Hi!

I've got this issue: I have a struct like this:

struct node
{
unsigned int m_code;
?? m_data;
unsigned int m_data_size;
};

Which is put into a list like std::list<node> myList;

Now the issue is with m_data. I want a general approach to store
anything into m_data no matter what it is. It could be a list of simple
chars, unsigned ints or double or float or whatever. My idea was that I
could create an array for m_data, filling it up with the appropriate
values but how'd I go about this? Lets take a basic sample -- Let's say
I want to store those values into my m_data (each into one single
struct):

double dv = 1.8464634...;
double* dv2 = new double[3];
dv2[0] = dv;
dv2[1] = dv;
dv2[2] = dv;
const char* cv = "Hello World...";

How can I store dv, cv and especially dv2 correctly into my m_data field
without wasting memory and without having to templatize the node struct?

Why do you not want to make node a template? Seems to me it would make
your life a whole lot easier:

template<typename T>
struct node
{
unsigned int m_code;
T m_data;
unsigned int m_data_size;
};

struct data_t
{
double dv;
double* dv2;
const char* cv;
// def ctor, copy ctor, assignment op, etc.
};

typedef std::list< node<data_t> > myList;

or, if data_t is large and you want to avoid excessive copying, maybe:

typedef std::list< node<data_t>* > myPtrList;

(maybe a smart pointer would be better).

Anyway, no "memory waste" that I can see here... what's the problem
exactly?

And the next question of course is -- how can I correctly read back
those values into my variables with the best perfomance possible?

Not sure I follow you... why do you have to "read them back" at all?
They'll be there on the list. If you need to copy them somewhere else
you'll have a copy ctor or assignment op to deal with that.

Could anyone provide me some simple sample code or give some hints on
how to go about this? I've thought about creating an array of e.g.
unsigned char and pushing the data into it. Would that work? If yes, how
would that look like?

Hmmm. Sounds like that might be messy, non-portable and that you might
hit all manner of gotchas over stuff like memory alignment.

Btw, just something I care for interest -- why will std::list<node*>
take much more memory than std::list<node> that is, when manually doing
a new node(); -> list.push_back(pointer_to_node) it takes more memory at
all than when using a value of std::list<node>?

Not sure I follow you here... I guess if you use std::list<node*> you
need to allocate storage for both the pointer on the list and the memory
you have (presumably) allocated for the node object it points to. is that
what you meant?

Actually having re-read your post it now sounds to me like you want to
store *different types* of node data on the same list - a polymorphic
list if you like - which is a whole other ball-park and which my brain
hurts too much to think about at the moment.

 

[Victor Bazarov]

I've got this issue: I have a struct like this:

struct node
{
unsigned int m_code;
?? m_data;
unsigned int m_data_size;
};

Which is put into a list like std::list<node> myList;

Now the issue is with m_data. I want a general approach to store
anything into m_data no matter what it is.

WHY? What are you modeling using that approach?

It could be a list of
simple chars, unsigned ints or double or float or whatever.

Really? Whatever? An airplain and a tomato, in the same list?

My idea
was that I could create an array for m_data, filling it up with the
appropriate values but how'd I go about this?

Again, why? What's the point, so to speak?

Lets take a basic sample -- Let's say I want to store those values
into my m_data (each into one single struct):

double dv = 1.8464634...;
double* dv2 = new double[3];
dv2[0] = dv;
dv2[1] = dv;
dv2[2] = dv;
const char* cv = "Hello World...";

How can I store dv, cv and especially dv2 correctly into my m_data
field without wasting memory and without having to templatize the node
struct?
void*

And the next question of course is -- how can I correctly read back
those values into my variables with the best perfomance possible?

You would have to store the type information beside the 'm_data'
member, and fill that information with whatever so you can recognise
the type later. Then use a big 'switch' statement (or some other
means) to convert the void* back into a pointer to the object of the
right type.

Could anyone provide me some simple sample code or give some hints on
how to go about this? I've thought about creating an array of e.g.
unsigned char and pushing the data into it. Would that work? If yes,
how would that look like?
Ugly.

Btw, just something I care for interest -- why will std::list<node*>
take much more memory than std::list<node> that is, when manually
doing a new node(); -> list.push_back(pointer_to_node) it takes more
memory at all than when using a value of std::list<node>?

Yes.

V

 

[Alexander Adam]

Hi!

I think this posting of Lionel (Thanks!) hits my idea at best:

Actually having re-read your post it now sounds to me like you want
to
store *different types* of node data on the same list - a polymorphic
list if you like [..]

That's *exactly* what I am looking for that is, no template based
struct node can be used in this case.

Oh and no, there won't be any tomatoes in the list ;-) Basically it
all goes down to a single type like bool, double, char or an array of
those values that's basically it.

Any idea?

Thanks + Regards
Alexander

 

[Thomas J. Gritzan]

Hi!

I think this posting of Lionel (Thanks!) hits my idea at best:

Actually having re-read your post it now sounds to me like you want
to
store *different types* of node data on the same list - a polymorphic
list if you like [..]

That's *exactly* what I am looking for that is, no template based
struct node can be used in this case.

A heterogenous list. Take a look at boost (http://www.boost.org/).

There are boost.variant and boost.any. Both will do, but I prefer variant,
because you can easily use the data by applying a 'visitor' on the list.

http://www.boost.org/doc/html/variant.html

There are also other ways but we need more information about what you want
to do with the data to give good advice.

 

[Lionel B]

Hi!

I think this posting of Lionel (Thanks!) hits my idea at best:

Actually having re-read your post it now sounds to me like you want to
store *different types* of node data on the same list - a polymorphic
list if you like [..]

As someone else pointed out, I think the term is "heterogeneous list"

That's *exactly* what I am looking for that is, no template based struct
node can be used in this case.

Actually, I think Victor Bazarov hit it best:

On Thu, 12 Jul 2007 13:22:05 -0400, Victor Bazarov wrote:

WHY? What are you modeling using that approach?

It would really help if you could explain what you are trying to
achieve... I always get the sneaking suspicion that lists of different
objects implies a design mis-think of some sort. Something along the
lines of: if the objects really are different why would they be on the
same list? Which implies that either (i) they shouldn't be on the same
list, or (ii) they are really not that different.

A common example of the latter might be where different types of objects
have different ways of "doing some particular thing". Eg.:

#include <iostream>
#include <list>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

struct node_base // abstract
{
virtual void do_something() const =0; // derived class implements
virtual ~node_base() {} // ensure derived class dtor called
};

struct type1_node : node_base
{
int a;
string s;
type1_node(const int a_, const string& s_) : a(a_), s(s_) {}
void do_something() const
{
cout << "type 1: a = " << a << "\ts = " << s << endl;
}
};

struct type2_node : node_base
{
vector<double> v;
type2_node(const double* const from, const double* const to) : v(from,to) {}
void do_something() const
{
cout << "type 2: v = ";
for (size_t i=0;i<v.size();++i) cout << '\t' << v;
cout << endl;
}
};

void dealloc(node_base* p)
{
delete p;
}

int main()
{
typedef list<node_base*> list_type; // smart pointer would be less clunky

list_type my_list;

// add some stuff to the list
my_list.push_back(new type1_node(3,"hallo"));
const double a[] = {3.0,-2.1,7.2};
my_list.push_back(new type2_node(a,a+3));

// each list member does its thing
for_each(my_list.begin(), my_list.end(), mem_fun(&node_base::do_something));

// avoid memory leak (wouldn't need this with smart pointer)
for_each(my_list.begin(), my_list.end(), dealloc);
}