Thread: Fields of a struct after freeing it - C

Hey all.

Suppose we have the following struct definition of Stack data structure implementation:

Code:

typedef struct StrStackLink {
   char* str;
   struct StrStackLink *next;
} StrStackLink; 

struct StrStack {
   StrStackLink* top;
};

Where its Pop method implementation is shown below:

Code:

char* StrStackPop(StrStack* stack)
{
   char *s;
   StrStackLink *p;
   assert( stack != NULL );
   if (stack->top == NULL) {
      return NULL;
   }
   s = stack->top->str;
   p = stack->top; // This lives in the HEAP
   stack->top = p->next;
   free(p);
   return s;
}

My question is about the line:

Code:

   s = stack->top->str;

Why is it correct?
After we free p struct (which is the former top), its str field is not "disappeared"?

Thanks in advance!

Originally Posted by john.c

The string would've (most likely) been separately allocated, so it has it's own place in memory that is separate from the struct, which only contains a pointer to the string. So freeing the struct doesn't free the string.

You take a copy of the pointer before freeing the struct so that you still have a reference to the string. If you didn't take a copy of the string pointer then you would lose the reference to the memory where the string is stored. That's called a "memory leak".

Eventually the string itself should be freed (if it was dynamically allocated in the first place).

That's the point - the string is not dynamically allocated. So, it shouldn't be freed.
But, if it's not dynamically allocated - does this string still live after we free the struct he is a field of?

Thank you!

Originally Posted by john.c

Yep. Why wouldn't it? If it's not dynamically allocated then free can't free it. It's either stored in an active stack frame or in the global memory space. The stack frame is deallocated when the function that allocated it returns. The global memory is deallocated when the program ends.

Got it.
Thank you!

Originally Posted by Salem

You need to show us your StrStackPush() and how you call it.

Because if you don't know where your strings are, chances are - you're doing it wrong.

So, in this particular example:

Code:

void StrStackPush(StrStack* stack, char* s) 
{
   assert( stack != NULL );
   StrStackLink *p = (StrStackLink*)
                              malloc(sizeof(StrStackLink));
   if (p == NULL)
   {
      printf("out of memory, cannot push a string to the
              stack\n");
      return;
   }
   p->str = s;
   p->next = stack->top;
   stack->top = p;
}

Code:

#include <stdlib.h>
#include <stdio.h>
#include "StrStack.h"
char * readline() {  ... } //A function to read a line 
int main() {
   char *line;
   StrStack *stack = StrStackNew(); 
   while ((line = readline()) != NULL)
   {
      StrStackPush(stack, line);
   }
   while ((line = StrStackPop(stack)) != NULL)
   {
      printf("%s\n", line);
      free(line);
   }
   StrStackFree(&stack); 
   return 0;
}

Where readline function returns a char pointer.

So as john has described - our str's here live in the main stack frame, which is also in charge of creating new pointers to new chars (by readline) using the temporary line pointer.

So, the pointer of each str lives as long as the main lives - which is until the end of the program.

Originally Posted by john.c

That's not quite right. Although the pointer lives on main's stack, the memory it points to is on the heap since it is (presumably) dynamically allocated by readline. Note that that memory is freed in main in the loop that pops the stack elements.

Oh yea. So readline is allocating str's eventually in the HEAP - so we have nothing to fear at all when we free the struct.

Thank you!