Structure Elements On The Heap vs The Stack

Question

So, I am creating a structure that currently needs a lot of memory. I hope to reduce it in the future, but for now, it is what it is. Hence, I need to allocate some of its elements on the heap because I get a stack overflow if they are put on the stack. And yes, I increased the stack size but on the target platform I only have so much.

In this case, would it be 'better' to allocate every structure element on the heap, or put some on the stack and the big stuff on the heap? For instance:

typedef struct my_structure_s{ 

   int bounds[2];
   int num_values;
   int* values;               //needs to be very large

} my_structure_t;

Vs:

typedef struct my_structure_s{ 

   int* bounds;
   int* num_values;
   int* values;

} my_structure_t;

I know 'better' is largely subjective, and could quite possibly incite a riot here. So, what are the pros and cons of both examples? What do you usually do? Why?

Also, forgive the _s, _t stuff...I know some of you may find it in bad taste but that is the convention for the legacy codebase this will be integrated into.

Thanks everyone!

Answer 1

It is better to keep the simple members as direct values, and allocate just the array. Using the extra two pointers just slows down access for no benefit.

One other option to consider if you have C99 or C11 is to use a flexible array member (FAM).

You'd define your structure using the notation:

typedef struct my_structure_s
{ 
   int bounds[2];
   int num_values;
   int values[];
} my_structure_t;

You'd allocate enough memory for the structure and an N-element array in values all in a single operation, using:

my_structure_t *np = malloc(sizeof(*np) + N * sizeof(np->values[0]));

This then means you only have to free one block of memory to free.

You can find references to the 'struct hack' if you search. This notation is effectively the standardized form of the struct hack.

---

In comments, the discussion continued:

This is an interesting approach; however, I can't guarantee I will have C99.

If need be, you can use the 'struct hack' version of the code, which would look like:

typedef struct my_structure_s
{
    int bounds[2];
    int num_values;
    int values[1];
} my_structure_t;

The rest of the code remains unchanged. This uses slightly more memory (4-8 bytes more) than the FAM solution, and isn't strictly supported by the standard, but it was used extensively before the C99 standard so it is unlikely that a compiler would invalidate such code.

Okay, but how about:

typedef struct my_structure_s
{
    int bounds[2];
    int num_values;
    int values[MAX_SIZE];
} my_structure_t;

And then: my_structure_t *the_structure = malloc(sizeof(my_structure_t));

This will also give me a fixed block size on the heap right? (Except here, my block size will be bigger than it needs to be, in some instances, because I won't always get to MAX_SIZE).

If there is not too much wasted space on average, then the fixed-size array in the structure is simpler still. Further, it means that if the MAX_SIZE is not too huge, you can allocate on the stack or on the heap, whereas the FAM approach mandates dynamic (heap) allocation. The issue is whether the wasted space is enough of a problem, and what you do if MAX_SIZE isn't big enough after all. Otherwise, this is much the simplest approach; I simply assumed you'd already ruled it out.

Note that every one of the suggested solutions avoids the pointers to bounds and num_values suggested in option 2 in the question.