structures containing structures vs. structures containing pointers

The following question is in regards to C programming. I am using Microchip C30 compiler (because I know someone will ask)

What is the difference between having a structure which contains several other structures vs a structure which contains several pointers to other structures? Does one make for faster code execution than the other? Does one technique use more or less memory? Does the memory get allocated at the same time in both cases?

If I use the following code does memory automatically get allocated for the subStruct?

// Header file...

typedef struct{
    int a;
    subStruct * b;
} mainStruct;

typedef struct{
    int c;
  开发者_如何学C  int d;
}subStruct;

extern mainStruct myMainStruct;

// source file...
mainStruct myMainStruct;

int main(void)
{
   //...
{

If you use a pointer, you have to allocate the memory yourself. If you use a substructure, you can allocate the entire thing in one go, either using malloc or on the stack.

What you need depends on your use case:

• Pointers will give you smaller struct's
• Substructures provide better locality of reference
• A pointer may point to either a single struct or the first member in an array of them, while substructures are self-documenting: there's always one of them unless you use an array explicitly
• Pointers take up some space, for the pointer itself + overhead from extra memory allocations

And no, it doesn't matter which compiler you use :)

Memory for pointers doesn't get automatically allocated, but when you contain whole structure in your struct, it does.

Also - with pointers you are likely to have fragmented memory - each pointed part of tructure could be in other part of memory.

But with poniters you can share the same substructures across many structs (but this makes changing and deleting them later harder).

Memory for a pointer wouldn't be automatically allocated. You would need to run:

myMainStruct.b=malloc(sizeof(*myMainStruct.b));

In terms of performance, there is likely a small hit to going from one structure to another via the pointer.

As far as speed goes, it varies. Generally, including structs, rather than pointers, will be faster, because the CPU doesn't have to dereference the pointer for every member access. However, if some of the members aren't used very often, and the sub-struct's size is massive, the structure might not fit in the cache and this can slow down your code quite a bit.

Using pointers will use /slightly/ more memory (but only the size of the pointers themselves) than the direct approach.

Usually with pointers to sub-structs you'll allocate the sub-structs separately, but you can write some kind of initialization function which abstracts all the allocation out to "the same time." In your code, memory is allocated for myMainStruct on the stack, but the b member will be garbage. You need to call malloc to allocate heap memory for b, or create a subStruct object on the stack and point myMainStruct.b to it.

What is the difference between having a structure which contains several other structures vs a structure which contains several pointers to other structures?

In the first case what you have is essentially one big structure in contiguous memory. In the "pointers to structures" case your master structure just contains the addresses to the sub-structures which are allocated separately.

Does one make for faster code execution than the other?

The difference should be negligible, but pointers method is will be slightly slower. This is because you must dereference the pointer with each access to the substructure.

Does one technique use more or less memory?

The pointer method uses number_of_pointers * sizeof(void*) more memory. sizeof(void*) will be 4 for 32-bit and 8 for 64-bit.

Does the memory get allocated at the same time in both cases?

No, you need to go through each pointer in your master struct and allocate memory for the sub-structs via malloc().

Conclusion

The pointers add a layer of indirection to the code, which is useful for switching out the sub-structs or having more than one pointer point to the same sub-struct. Having different master-structs pointing to common sub-structs in particular could save quite a bit of memory and allocation time.