Using free() on a pointer within a struct frees memory for the entire struct

Question

I have two structs within my program. The first one, huffchar is below, and just shows the general structure (mostly irrelevant to the question), but the second one, huffcoder is the one that I'm having an issue with:

struct huffchar {   
    int freq;   
    int is_compound;   
    int seqno;   
    union {
        struct {
        struct huffchar * left;
        struct huffchar * right;
        } compound;
        unsigned char c;   
    } u; 
};


struct huffcoder {   
    int freqs[NUM_CHARS];
    int code_lengths[NUM_CHARS];
    unsigned long long codes[NUM_CHARS];
    struct huffchar * tree;
    int sizeOfTree; 
};

When I initialize a huffcoder in my program, I malloc ourHuffCoder the size of a huffcoder, and then malloc memory for X many elements to the struct huffchar * tree:

struct huffcoder * ourHuffChar = malloc(sizeof(struct huffcoder));

ourHuffChar -> tree = malloc(sizeof(struct huffchar)*NUM_CHARS);

However, I will need to make this tree larger at a later point, and do not know how many elements will be on this tree at the end. In other words, every time I add an element, I will create a new tree with realloc() that is one element larger, then set the pointer for tree within the huffcoder to this new updatedTree.

The follow lines of code are intended to achieve this:

    struct huffchar * updatedTree = realloc(ourHuffCoder -> tree, (ourHuffCoder->sizeOfTree+1)*sizeof(struct huffchar));
    free(ourHuffCoder -> tree);
    ourHuffCoder -> tree = updatedTree;

Note that I use the line free(ourHuffCoder -> tree) to free the memory that has been previously allocated to the tree, before updating the tree pointer to updatedTree. However, when I reach the free(ourHuffCoder -> tree) line, memory allocated to the entirety of the HuffCoder pointer ourHuffCoder is freed instead of just the memory allocated to the tree.

Here is my variables window before running the free(ourHuffCoder->tree) line:

And here is after running the free(ourHuffCoder->tree) line:

I have also tried creating an entirely new pointer huffchar * ourTree = ourHuffCoder -> tree and use this variable for the free() method instead, but I get the same result.

Just to test my code, I modified the above code to remove the free() line,

    struct huffchar * updatedTree = realloc(ourHuffCoder -> tree, (ourHuffCoder->sizeOfTree+1)*sizeof(struct huffchar));
    ourHuffCoder -> tree = updatedTree;

This is obviously not what I should be doing because I will run out of memory quickly, but I wanted to see if the pointer to tree within huffcoder would be updated to point to updatedTree, which is has:

Before ourHuffCoder -> tree = updatedTree;

After ourHuffCoder -> tree = updatedTree;

My question is, why is the memory allocated to the entirety of the huffcoder struct being freed, instead of just the memory to the tree? How do I solve this? Is there a better way of increasing the memory allocated to the tree?

Are you freeing a pointer to the first element of a struct, which of course shares the address with the whole struct? A) You cannot free parts. B) How do you expect the system to tell apart whether you want to free all or only the first? C) Did you try freeing a later member of the struct? — Yunnosch
– Yunnosch, Commented Nov 20, 2019 at 0:14
en.cppreference.com/w/c/memory/realloc "The reallocation is done by...allocating a new memory block..., copying memory area..., and freeing the old block." So you don't want to free it because double freeing memory causes undefined behaviour. — Jerry Jeremiah
– Jerry Jeremiah, Commented Nov 20, 2019 at 0:26

Kaz · Accepted Answer · 2019-11-20 00:28:13Z

3

The mistake I see is that realloc is already a combination of malloc and free. The free call here is unnecessary and wrong:

struct huffchar * updatedTree = realloc(ourHuffCoder -> tree, (ourHuffCoder->sizeOfTree+1)*sizeof(struct huffchar));
free(ourHuffCoder -> tree);
ourHuffCoder -> tree = updatedTree;

That is to say, when we call realloc(ptr), ptr is deallocated and a new pointer is returned. The allocator can sometimes optimize the process by resizing the old object in place.

There is no need to free ptr, and we must not do so, in fact.

If we didn't care about the optimization, we could almost write realloc like this:

#include <string.h>
#include <stdlib.h>
#define min(a, b) ((a) < (b) : (a) : (b))

void *our_realloc(void *oldptr, size_t newsize)
{
   if (newsize == 0) {
      free(oldptr);
      return 0;
   } else {
      void *newptr = malloc(newsize);
      if (oldptr) {
         size_t oldsize = __obtain_old_size_in_nonportable_way(oldptr);
         memcpy(newptr, oldptr, min(oldsize, newsize));
         free(oldptr); // !!!!
      }
      return newptr;
   }
}

Even in cases when realloc returns the "same" pointer, the program cannot easily tell. The old pointer has become invalid, so any use of it is undefined behavior:

newptr = realloc(oldptr, size);

if (newptr == oldptr) {  // did it really move?

The use of oldptr here is technically undefined behavior. We never hold the two pointers simultaneously; we have traded one for the other and the transaction took place inside the realloc blackbox.

We can capture a printed image:

char oldptr_txt[64], newptr_txt[64];
snprintf(oldptr_txt, sizeof oldptr_txt, "%p", (void *) oldptr);
newptr = realloc(oldptr, size);
snprintf(newptr_txt, sizeof newptr_txt, "%p", (void *) newptr);

if (strcmp(oldptr_txt, newptr_txt) == 0) {
  // almost certainly stayed in place
} else {
  // almost certainly moved
}

edited Nov 20, 2019 at 0:28

answered Nov 20, 2019 at 0:14

Kaz

59.1k10 gold badges113 silver badges167 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Nicolas Miari Over a year ago

I don't understand why it is undefined beahviour to compare the two pointers; aren't they just compared as integer-valued memory addresses? When you pass oldptr to realloc(), it is passed by value; the contents pointed at are potentially copied to a new address (returned intop newptr), the beginning of a contiguous region of the required size. But the value of the pointer oldptr` (i.e., the old address), not the pointed-at object, should be unchanged, right? Why is it undefined to compare the value of the (invalid) old pointer and the new one? What am I missing?

Kaz Over a year ago

@NicolasMiari It works fine on every compiler I've used, but ISO C says that when memory is freed, the pointer becomes indeterminate. Use of an indeterminate value is undefined behavior.

Collectives™ on Stack Overflow

Using free() on a pointer within a struct frees memory for the entire struct

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related