local structure and pointers

Question

I have a function which takes a structure as a parameter, like:

add_new_structure(structure s);

then store it inside structure structure_list[200];

question:

1. when I want to use the structure, I have a function like

structure *getStructure(int id)
{
return &structure_list[id];
}

is it gonna work if I add one structure like this:

void init()
{
   structure test;
   memset(&test,0,sizeof(structure));
   add_new_structure(test);
}

and then call getStructure from another function? like this:

void anotherFunction()
{
    structure *got_test = getStructure(0);
}

because I remember I can't have local variable and then call it from another function right?

2.is it better to just store it like this?

change the add_new_structure() parameter to structure *s;

then store it inside structure *structure_list[200]; by calling add_new_structure(&test);

3. which one is better? or what is the right way to do it?

Does `structure_list` have static storage duration? You might want to post the definition of `add_new_structure()` and the `struct`. If the `struct` has any pointers then just copying them can be dangerous. — hmjd, Oct 24 '12 at 10:43
yes it has a long list of structure members,contain char pointers,so how to store them in array safely? what is static storage duration? — steave, Oct 24 '12 at 10:45
static storage duration means lasts for the lifetime of the program (see http://stackoverflow.com/questions/95890/what-is-a-variables-linkage-and-storage-specifier). — hmjd, Oct 24 '12 at 10:48

Summer_More_More_Tea · Accepted Answer · 2012-10-24T11:21:22.777

The first approach, i.e. you pass the instance directly as a parameter, works. Because the whole instance is copied when calling the function. And what you store is a copy of the original struct instance.

However, you can't pass and store a pointer to a local variable. The problem you mentioned above will occur in this case.

IMHO, neither of the above approaches are right. The first approach will introduce too much overhead when passing parameters to the function. While the second one cannot achieve what you want. You'd better dynamically allocate memory with malloc/calloc and store the pointer in the array. Don't forget to release the object at the end of use in case of memory leak. Like this:

void init()
{
   structure *test = NULL;
   test = (structure *) calloc(1, sizeof(structure));
   add_new_structure(test);
}

void add_new_structure(structure *s);

score 0 · Answer 2 · answered Oct 24 '12 at 11:11

Option 2, as I think you point out, will not work. It's a bit more subtle than saying that pointers to local variables can't be used outside of a function; it's that they are only valid while the function is still "active", so to speak. In option 2, a pointer to structure test would be stored inside of structure *structure_list[200] when you call add_new_structure. At this point, some function is calling init which is calling add_new_structure. When you return from init, the memory address you put into structure_list is no longer owned by the original owner, and this is dangerous. If this is too mechanical of an explanation, you should look at how stacks work to see why.

Without using malloc and its friends, which can introduce a lot of complexity, I would be inclined to keep the memory stored in structure_list, with the minor modification that you can pass structure test by reference and not by value. This is probably a reasonable compromise between the two stylistically.

void init() {
    structure test;
    memset(&test,0,sizeof(structure));
    add_new_structure(&test);
}

void add_new_structure(structure *s) {
    if (structure_count < 200) {
        structure_list[structure_count++] = *s;
    }
}

A lot of this depends on what structure is (if it contains pointers itself, who owns those?), but hopefully this provides some intuition.

local structure and pointers

2 Answers2