Realloc gives invalid pointer error when resizing array

You are passing an uninitialised variable to your function, in turn passed to realloc, which needs either a pointer to previously allocated memory, or NULL.

So initialise that variable:

int *numbers = NULL;

There are multiple issues in your code:

• you do not initialize numbers to NULL, so realloc() invokes undefined behavior the first time it is called. This is causing the problem you observe.
• you do not check the return value of scanf(), causing a potential endless loop and undefined behavior if the input stream does not contain a 0 number.
• you do not store the number in the reallocated array...
• you do not free the array (minor).
• you do not return 0 at the end of main() (minor).

Here a simpler and safer version:

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

int *resizeIntArray(int *series, int newSize) {
    int *newSeries = realloc(series, newSize * sizeof(int));
    if (newSeries == NULL) {
        printf("Error: Memory allocation failed");
        exit(-1);
    }
    return newSeries;
}

int main(int argc, char *argv[]) {
    int number;
    int *numbers = NULL;
    int i, size = 0;

    /* reading the numbers */
    while (scanf("%d", &number) == 1 && number != 0) {
       numbers = resizeIntArray(numbers, size + 1);
       numbers[size++] = number;
    }
    /* printing the numbers */
    for (i = 0; i < size; i++) {
       printf("%d ", numbers[i]);
    }
    printf("\n");

    free(numbers);
    return 0;
}

You can try an approach like this. This includes:

• Memory checking, with appropriate error messages.
• use of malloc() and realloc() to allocate and reallocate memory.
• Allocates sufficient space when needed on run-time.
• Appropriately checks return value of scanf().

Here is the code:

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

#define EXIT 0

void exit_if_null(void *ptr, const char *msg);

int
main(int argc, char const *argv[]) {
    int *numbers = NULL;
    int number, num_size = 1, count = 0, i;

    /* initial allocation of memory */
    numbers = malloc(num_size * sizeof(*numbers));

    /* small error checking, to be safe */
    exit_if_null(numbers, "Initial Allocation");

    /* Reading in numbers */
    printf("Enter numbers(0 to end): ");
    while (scanf("%d", &number) == 1 && number != EXIT) {

        /* valid number found, but is there space? */
        if (num_size == count) {
            num_size *= 2;

            /* resize run-time array */
            numbers = realloc(numbers, num_size * sizeof(*numbers));
            exit_if_null(numbers, "Reallocation");
        }
        numbers[count++] = number;
    }

    /* print out numbers */
    printf("Your numbers stored in array:\n");
    for (i = 0; i < count; i++) {
        printf("%d ", numbers[i]);
    }

    /* free allocated memory, very important */
    free(numbers);

    return 0;
}

/* helper function for error checking */
void
exit_if_null(void *ptr, const char *msg) {
    if (!ptr) {
        printf("Unexpected null pointer: %s\n", msg);
        exit(EXIT_FAILURE);
    }
}

First you should first allocate some memory before reallocate it. So your code will change as:

#include <stdio.h> 
#include <stdlib.h>
int *resizeIntArray(int *series, int newSize){
int *newSeries = realloc(series,newSize*sizeof(int));
if(newSeries == NULL){
 printf("Error: Memory allocation failed");
 exit(-1);
 }
return newSeries;
}
int main(int argc, char* argv[]) {
   int number;
   scanf("%d",&number);
   int *numbers=malloc(sizeof(int));///CHANGED
   int size = 1;///CHANGED
   while(number != 0){
   numbers = resizeIntArray(numbers,size +1);
   printf("%d ",number);
   scanf("%d",&number);
   size++;
 } 
}

But white you are doing is quite not efficent. A realloc() function hides a free() a malloc() and the worst one: memcpy(). So if you realloc() at each new item, you are going to have a bad time... O(n^2) exactly. the best way to do it is to allocate a buffer of memory:

  struct vector
  {   
      int *numbers;
      size_t size;
      size_t i;
   }
   #define DEFAULTBUF 100
   int main()
   {
          struct vector v;
          v.numbers=malloc(sizeof(int)*DEFAULTBUF);
          v.size=DEFAULTBUF;
          v.i=0;
          scanf("%d",&number);
          while(number != 0 && v.numbers){
             if (v.i->=v.size)
              {   v.size+=v.size
                 v.numbers=realloc(v.numbers,sizeof(int)*v.size);
               ///i leave to you the error handling
               }
               v.i++;
              printf("%d ",number);
              scanf("%d",&number);

             }  

   }

The correct use of realloc() malloc() and similar is very important. And also the increasing ratio of the resize. For the datastructure I ever double it. For text I proceed linearly