Thread: declaring instances of parent structs at the end of the struct, instead of in main

A quick question about declaring parent structs (structs with structs inside them):

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


/*
 * 
 */


struct basic_struct {
    
    int day;
    int month;
    int year;
    char date [12];
    
};


struct gsm_struct {
    
    char Callcomm[15];
    char Textcomm[15];
    char Hangupcomm[15];
    
};


struct dynamic_struct {
    
    struct basic_struct inner_struct;
    struct gsm_struct gsm;
    
};


int main(int argc, char** argv) {


    
    
    return (EXIT_SUCCESS);
}

In the above code, should I initialize instances of dynamic_struct at the end of the struct declaration? like so:

Code:

struct dynamic_struct {
    
    struct basic_struct inner_struct;
    struct gsm_struct gsm;
    
} gsm, banana, example;

More to my question, if I initialized and instance in the main loop, would it create structs within structs infinitely? I have read it is also best practice to declare a pointer to the infant struct within the parent struct, in order to avoid the same problem. like so:

Code:

struct dynamic_struct {
    
    struct basic_struct *inner_struct;
    struct gsm_struct *gsm;
    
};

That way you can initialize inside the main loop without infinite overflows. Is this true?

Thanks in advance
MedicineMan25

> In the above code, should I initialize instances of dynamic_struct at the end of the struct declaration? like so:
No, that just creates global variables with default initialisations.

You should do this

Code:

int main ( ) {
  struct dynamic_struct gsm = {
    { /* init list for basic_struct */ },
    { /* init list for gsm_struct*/ }
  };

}

> if I initialized and instance in the main loop, would it create structs within structs infinitely?
Not in this example it wouldn't.

In fact the compiler won't even let you create infinite structures to begin with, so it isn't a problem you need to worry about accidentally running into.

The only time you HAVE to worry about this is when you're creating recursive data structures like linked lists.

Code:

struct list {
  struct list *next;
};

A struct can contain pointers to itself, it just can't contain instances of itself.

> struct gsm_struct *gsm;
Pointers to other structs come in handy in a couple of circumstances.
1. if gsm_struct is particularly large (say 10's of KB), then creating lots of instances of it directly on the stack might be a problem. In that case, you might prefer to allocate the bulk of the data via malloc instead.

2. If you have a dynamic number of gsm connections to maintain, then you could do things like this
var.gsm = malloc( numConnections * sizeof(struct gsm_struct) );
This gives you say var.gsm[0].Callcomm to var.gsm[numConnections-1].Callcomm to play with.