Re: Solving a template/struct issue
On Fri, 13 Jul 2007 06:06:49 +0000, Alexander Adam wrote:
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[i];
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);
}
--
Lionel B