Home / Questions / 35380
Accepted
NaCl
Asked: 2020-11-23 14:16:40 +0800 CST 2020-11-23 14:16:40 +0800 CST

What happens to the original pointer after reallocating to a temporary one?

  • 772

I'm developing an application that requires to put/free and re-allocate memory in a somewhat excessive way, but I have a doubt regarding the use of the function realloc(void *, size_t), I have the following code:

void Resize(void *ptr, size_t sz) {
    if (ptr == NULL || sz == 0) 
        return;                   /* No se ve afectado. */

    void *tmp = realloc(ptr, sz); /* Aquí sucede mi problema. */

    if (tmp == NULL) 
        return;                   /* No pasa nada en caso de NULL */

    /* Otra logica... */
}

On the line: void *tmp = realloc(ptr, sz);my question is the following:

If after this line I release the memory ptras follows:

free(ptr);

Will the pointer tmpstill be valid and point to the new ^ memory address given by realloc?

^: I say new because I don't know if it reallocworks mallocto give memory addresses by resizing them.

c

2 Answers

  1. Best Answer

    If after that line you release ptr, tmpit will no longer be valid. Here's an example:

    #include <stdlib.h>

int
main(int argc, char *argv[]) {
   int *ptr;
   int *tmp;

   ptr = malloc(128);
   tmp = realloc(ptr, 256);
   free(ptr);
   free(tmp);

   return 0;
}

    When you run the code you get:

    Error in `./test': double free or corruption (top): 0x00000000019cb010

    reallocit works as mallocif it ptris NULL. If sizeit is 0then it reallocworks like free.

    Here another example:

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

int
main(int argc, char *argv[]) {
   int *ptr;
   int *tmp;

   ptr = malloc(128);
   tmp = realloc(ptr, 256);

   printf("%p == %p\n", ptr, tmp);

   free(ptr);

   return 0;
}

    And you will see that both addresses are the same.

    • 5

  2. The functions to work with dynamic memory are:

    • malloc: This function allows us to reserve a memory area of ​​the size we want.
    • calloc: Similar to malloc. In addition to reserving memory, it initializes all bytes to 0.
    • realloc: Attempts to relocate the data to a different memory zone according to the new requirements (these new requirements may imply a larger or smaller zone).
    • free: This function releases the memory reserved with any of the above three methods.

    A possible example of the implementation of realloccould be the following:

    void* realloc(void* ptr, size_t size)
{
  // Si se indica tamaño 0 no se hace nada
  if( size == 0 )
    return ptr;

  void* newPtr = malloc(size);
  if( newPtr != NULL && ptr != NULL )
  {
    // Si hemos conseguido una nueva zona de memoria
    // Movemos los datos (si la nueva zona es más pequeña)
    // no podemos copiar toda la memoria)
    memcpy(newPtr,ptr,size);
    free(ptr);
  }

  return newPtr;
}

    Namely:

    • If the new size is indicated to be 0, nothing is done and the memory is not freed.
    • If memory cannot be reserved, nothing is done and the memory is not released
    • If the reservation has been made and is larger, the contents of the old memory are copied to the new memory and the old memory is freed
    • If the reservation has been made and is smaller, whatever will fit in the new memory is copied and the old memory is freed.

    That said, if you do the following:

    void* tmp = realloc(ptr, 256);
free(ptr);

    The result will be one of the following possibilities:

    • Yes tmp==NULL, you will be losing the original memory with no way back.
    • Yes tmp!=NULL, you will be trying to free a memory zone that is already freed and that usually causes the application to close.

    And none of these options seem to be desirable.

    What you have to do is reserve freefor when you really no longer need the memory you are using. The following example has no memory leaks:

    void* tmp = realloc(NULL, 256); // (1)
void* tmp2 = realloc(tmp,100); // (2)
void* tmp3 = realloc(tmp2,150); //(3)
free(tmp3); //(4)

    And it does the following:

    1. Makes a memory reservation of 256 bytes
    2. Makes a memory allocation of 100 bytes and if the allocation is correct copies the first 100 bytes of the old memory and then frees the old memory
    3. Allocates 150 bytes of memory, copies old memory to new memory, then frees old memory
    4. Free the 150-byte region. At this point there is no memory reserved.
    • 2