Realloc returns NULL, but does not set errno. How do I properly check for this error/odd behavior?

Question

Consider this code:

main() {
   float *ptr = NULL;
   while(true) {
      ptr = (float *)realloc(ptr, 0*sizeof(float));
      fprintf(stdout,"Errno: %d, Ptr value: %d\n",errno, (int)ptr);
   }
}

What is odd is that errno is never set (at least for me) but the call alternatively returns NULL and a pointer value. My thinking is that 0 allocations can return an error of a sort, but not one severe enough to set errno. Or the code with realloc is problematic. I am not sure.

I sort of would not care, but this is causing me a (0 byte) memory leak.

The 'Realloc Failure' question is not quite the same as it largely assumes that a NULL return from realloc() is an error. This is not the case in this situation. This is mostly about the different behavior of realloc() when a zero size is passed to it.

Answer 1

Looking at:

https://code.woboq.org/userspace/glibc/malloc/malloc.c.html#__libc_realloc

I can see what is going on. Based on the code, if the input pointer is not null, and the new size is 0, then it frees the old pointer and returns NULL.

If, however, the input pointer is NULL, then realloc just acts as a malloc and returns what malloc(0) produces. (In this case, it does not check if the size is 0 or not.)

So, there is no errno because there is no error. But realloc() returning a NULL is not necessarily an error, which is a nuance I did not recognize.

So, in this example, the first call (0 size, NULL ptr) returns an allocated pointer to a zero sized data area. The second call ( 0 size, non-NULL ptr) the routine frees the pointer and returns a NULL. And then the cycle repeats.

Answer 2

realloc returns NULL, but does not set errno. How do I properly check for this error/odd behavior?

For realloc(), errno is not specified to be set by the C standard. Any setting of errno is an implementation defined behavior here.

C does specify:

If the size of the space requested is zero, the behavior is implementation-defined: either a null pointer is returned to indicate an error, or the behavior is as if the size were some nonzero value, except that the returned pointer shall not be used to access an object. C17/18 § 7.22.3 1

If size is zero and memory for the new object is not allocated, it is implementation-defined whether the old object is deallocated. C17/18 § 7.22.3.5 3

Consider avoiding 3 implementation-defined behavior points. Use a helper function and call free() when the new size is 0.

// Return error status
bool realloc_float(float **ptr, size_t new_size) {
  // Size zero or too big ....
  if (new_size == 0 || new_size > SIZE_MAX/sizeof(float)) {
    free(*ptr);
    *ptr = NULL;
    return new_size > 0;  // fail on large new_size
  }
  float *newp = realloc(*ptr, sizeof(float) * new_size);
  if (newp == NULL) {
    free(*ptr);
    *ptr = NULL;
    return true; // failure
  }
  *ptr = newp;
  return false;
}

Usage

int main() {
   float *ptr = NULL;
   for (int i = 0; i < 10; i++) {
      size_t sz = rand()%4; 
      bool err = realloc_float(&ptr, sz);
      printf("Error: %d, Ptr value: %p, size %zu\n", err, (void*)ptr, sz);
   }
   free(ptr); 
}

Answer 3

Just use an intermediate variable. For example

int main( void ) {
   float *ptr = NULL;
   while(true) {
      float *tmp = realloc(ptr, 0*sizeof(float));

      if ( !tmp ) 
      {
          // report an error
          break;
      }

      ptr = tmp;
      //...
   }
}

As for a zero-sized memory request then according to the C Standard (7.22.3 Memory management functions)

If the size of the space requested is zero, the behavior is implementation-defined: either a null pointer is returned, or the behavior is as if the size were some nonzero value, except that the returned pointer shall not be used to access an object.