Re: Solving a template/struct issue
On Thu, 12 Jul 2007 15:52:05 +0000, Alexander Adam wrote:
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.
--
Lionel B