How to instantiate a std::list contained in a struct.

I'm new to C++ (math major here). Here's a simple example of what I'm trying to do.

Suppose I have some struct, we'll call it simple.

Code:

typedef struct simple
{
  int a;
}simple;

Now, suppose I have another struct that contains some data, and an std::list that will hold type simple:

Code:

typedef struct _tx_info
{
  int something;
  list<simple*> simple_list;
}tx_info;

Now, in main, if I want to create a type of tx_info, and use that list, I'm not sure what the
syntax is just to instantiate the list..

Code:

int main(int argc, char ** argv)
{
  tx_info * info = (tx_info*)malloc(sizeof(tx_info));
  simple * s = (simple*)malloc(sizeof(simple));
  s->a = 10;
  info->simple_list.push_front(s);                                            
  return 0;
}

Obviously, this will segfault because I never instantiate the list.

What's confusing to me, is if at the top of the C++ file, I do

Code:

list<simple*> simple_list;

that will both declare and instantiate a list. I'm not sure how to instantiate it when my list is
declared within a struct.

Thanks so much for the help!

I think I got it.

In my struct, I make it a pointer to a list.

And before I call push_front, I do

Code:

info->simple_list = new list<simple*>();

This is exactly why people here tell everyone NEVER to use malloc in C++. Use "new" and "delete"; then it should at least call the list constructor, and then it ought to work.

Originally Posted by EVOEx

This is exactly why people here tell everyone NEVER to use malloc in C++. Use "new" and "delete"; then it should at least call the list constructor, and then it ought to work.

are you talking about my tx_info struct? I should be calling new instead of malloc?

Since you want to instantiate a list in a struct, I would write a constructor for the struct. The only real difference between struct and class in C++ is that struct makes everything public by default, where class makes everything private by default.

Code:

tx_info * info = (tx_info*)malloc(sizeof(tx_info));

If you were using `new', the default constructor for `_tx_info' would construct the `std::list<simple*>' data member.

As EVOEx said, `malloc' and `free' really don't belong in C++ code.

Soma

Originally Posted by dayalsoap

I think I got it.

In my struct, I make it a pointer to a list.

And before I call push_front, I do

Code:

info->simple_list = new list<simple*>();

No no NO! That is very very wrong.
You do not do anything to instantiate the list. The code creating an instance of the struct doesn't even have to know that it contains a list.
It doesn't work simply because you're using malloc. Do not use malloc in C++! Only use the 'new' keyword, and only in the places where you are currently using malloc.
It will just work without you having to do anything.

Originally Posted by whiteflags

Since you want to instantiate a list in a struct, I would write a constructor for the struct.

You don't need to write a consturctor here, and for this example one certainly shouldn't.
A list knows how to construct itself. It will all just work if the OP doesn't ever use malloc in a C++ program.

malloc, memset, memcpy etc should all be banned from any C++ program. They outright destroy the ability for things to work properly.

Originally Posted by iMalc

You don't need to write a consturctor here, and for this example one certainly shouldn't.
A list knows how to construct itself. It will all just work if the OP doesn't ever use malloc in a C++ program.

malloc, memset, memcpy etc should all be banned from any C++ program. They outright destroy the ability for things to work properly.

I certainly agree with you here, but there may be a reason to write a constructor after all:

Originally Posted by dayalsoap

I think I got it.

In my struct, I make it a pointer to a list.

And before I call push_front, I do

Code:

info->simple_list = new list<simple*>();

Now, a pointer to a list containing simple is list<simple>*. In which case we'd want to write

Code:

 list = new list<simple>;

in a constructor and clean it up with RAII.

Even if the type is correct by OP as written, meaning that he actually wants a list of simple pointers ( list<simple*> ) there is still some work to be done in a constructor/destructor pair. The constructor might be empty in that case actually but the destructor would need to free the nodes in the list,

Code:

list<simple*>::iterator node;
while ( iter < list.end() ) {
   node = iter++;
   delete *node;
}

since all the elements would be new'd pointers.

In general the idea is a mess since simple isn't even a base class, but if you're going to do something like this....

There is also no need for typedef.
struct simple
{
int a;
};
As simple as that.
I think you are poisoned by C. I would recommend you get a C++ book and start from the beginning. Forget C. Learn C++.
A good book is Accelerated C++.

Originally Posted by whiteflags

Now, a pointer to a list containing simple is list<simple>*. In which case we'd want to write

Whilst that is technically true, this is not a pointer to a list, and most people will probably never come across a case where their struct should actually contain a pointer to a list. It should just be a list, as it is already.

Even if the type is correct by OP as written, meaning that he actually wants a list of simple pointers ( list<simple*> ) there is still some work to be done in a constructor/destructor pair. The constructor might be empty in that case actually but the destructor would need to free the nodes in the list

If the list contains dynamically allocated items then a destructor is required (amoung other things), but a constructor (other than a copy-constructor) is not required, and should only be used if there are other reason to have it.

We'd probably find though that if we got to see more of the code, that the list would be best to contain the actual objects, rather than pointers anyway.

Originally Posted by Elysia

I think you are poisoned by C.

agreed