When I allocate memory to a struct of structs, do I have to do it for each of its attributes or just for the container?

As you comment, the memory is reserved with malloc such that:

puntero = (struct tipo*)malloc(sizeof(struct tipo));

That is, the number of reserved bytes will depend on the value returned by sizeof().

Well, if we have a structure such that:

struct datos
{
  int dato1;
  int dato2;
};

And we print its size:

printf("%d", sizeof(struct datos));

It will return us, typically 8, that is, 4 bytes corresponding to dato1and another 4 corresponding to dato2.

Now let's create a second structure that contains the first:

struct datosAvanzados
{
  struct datos datos;
  int otrosDatos;
};

printf("%d", sizeof(struct datosAvanzados);

It will now sizeof()return 12, i.e. 4 bytes for each int. Nested structures increase the size of the pool .

If we now create a second struct pointing to the first:

struct punteroADatos
{
  struct datos* ptr;
};

printf("%d", sizeof(struct punteroADatos);

We see that now it prints 4 (if we are in 32 bits) or 8 (64 bits). That is, by using pointers, you reserve space solely for storing a memory address .

That is, when reserving memory you only have to worry about the pointers, since they will remain pointing to random positions . This can be fixed by replacing mallocwith calloc. The rest of the variables, no matter how many nesting levels you have, will have their own memory address assigned.

When I allocate memory to a struct of structs, do I have to do it for each of its attributes or just for the container?

You should only allocate memory with mallocfor the node (i.e. for the struct tNode).

1. Structure:

We only need to worry about reserving memory mallocfor this structure ( tNode). You don't need to allocate memory to the pointer/member next, but you do need to have a reference (base address) to the next node.

typedef struct tNode {
    tPila e;
    struct tNode *next;
} tPilaStackNode;

2. Structure:

The structure tPiladoes not need to reserve memory with malloc, it can be defined as a local variable and assign the respective data to the member that has the nested structure tElement.

typedef struct {
    tElement element;    
} tPila; 

3. Structure:

The structure tPilaStackdoes not need to be created in memory with malloc, it can be defined as a simple local variable (it will have an automatic storage, it is created when the function is called and released when the subroutine finishes executing), what if we must take into account, is the member first. The pointer firstmust have the memory address of the first attribute/member of the last node. So if this pointer doesn't have a reference that's valid, you'll run into problems at runtime. The content of first, will depend on the path of each node of the stack.

typedef struct {
    tPilaStackNode *first;
} tPilaStack;

As I can see, if the main element is a stack, therefore what I want is to create a function that adds an element to the stack, that is, a push.

PilaStack_push(tPilaStack *stack, tPila Pila) {

}

A possible implementation for the function PilaStack_pushwould be:

tPilaStackNode* PilaStack_push(tPilaStack *stack, tPila Pila)
{
    tPilaStackNode* newNode = malloc(sizeof(tPilaStackNode));
    if(newNode == NULL)
        return NULL;
    newNode->e.element.data = Pila.element.data;
    newNode->next = stack->first;
    stack->first = newNode;
    return newNode;
}

Let's focus on the parameters stackand Pila. Both parameters can be passed a structure variable with automatic or static storage, it does not necessarily have to be dynamic.

We would call the function like this:

int main(void)
{
    tPilaStack stack = {NULL};
    tPila pila = {10};
    PilaStack_push(&stack, pila);
    free(stack.first);
    return 0;
}

Functioning:

• We assign to the member first(of the structure tPilaStack) a default value, that is, NULL(remember that the stack must have a node with a member pointing to NULLto define a start and end in the stack).

• We assign the value of 10to the member that has the nested structure tElement.

• Lastly, we pass the base address of the struct tPilaStackto the first parameter, and to the second, we pass the copy of the struct's content tPila.

If you notice, I didn't have to reserve memory directly with mallocany member.