Adding string to array, pointer being realloc'd was not allocated

In your while (*array) loop you are incrementing not only the size, but also the array pointer itself. As a result, at the end of the loop size contains the length of the array, and the array pointer points to the last (NULL) element. This pointer was never allocated, (it points within an allocated block,) therefore it is not a valid pointer to reallocate. (And definitely that's not what you intended to do.)

So, just don't do array++ within that loop.

Your loop that calculates the number of strings in the array also advances the variable itself. You could use a temporary variable instead:

char **temp = array;
while (*temp)
     ...

Or separate the counting into a function.

BTW you don't need a casting when using realloc, for the same reason you don't do the casting with malloc. This is not a bug, but it better be consistent.

Summarizing all other answers given so far, adding some best practise tweaks, the relevant code should look like this:

char **add_string(char **array, const char *string)
{
  char ** newarr;
  size_t size = 0;

  assert (NULL != string); /* Need to include assert.h */

  if (NULL != array)
  {
    while (NULL != array[size]) 
    {
      ++size; /* Just count, do not touch the pointer value allocated. */
    }
  }

  newarr = realloc(array, (size + 2) * sizeof *newarr);
  if (NULL == newarr) /* Test the outcome of reallocation. */
  {
    perror("realloc() failed"); /* Need to include stdio.h */
    return NULL;
  }

  newarr[size] = malloc(strlen(string) + 1);
  if (NULL == newarr[size])
  {
    perror("malloc() failed"); /* Need to include stdio.h */
    /* Might want to clean up here and indicate the failure to the 
       caller by returning NULL. */
  }
  else
  { 
    strcpy(newarr[size], string);  
  }

  newarr[size+1] = NULL;

  return newarr;
}

Or even tighter:

char **add_string(char **array, const char *string)
{
  assert (NULL != string); /* Need to include assert.h */

  {
    size_t size = 0;

    if (NULL != array)
    {
      while (NULL != array[size]) 
      {
        ++size; /* Just count, do not touch the pointer value allocated. */
      }
    }

    {
      char ** newarr = realloc(array, (size + 2) * sizeof *newarr);
      if (NULL == newarr)
      {
        perror("realloc() failed"); /* Need to include stdio.h */
      }

      if (NULL != newarr)
      {  
        newarr[size] = malloc(strlen(string) + 1);
        if (NULL == newarr[size])
        {
          perror("malloc() failed"); /* Need to include stdio.h */
        }
        else
        { 
          strcpy(newarr[size], string);  
        }

        newarr[size+1] = NULL;
      }

      return newarr;
    }
  }
}

The easiest way would be to preserve initial array pointer and use it to realloc memory.

int main(void)
{
    char **strings = init_array();

    strings = add_string(strings, "one");
    strings = add_string(strings, "two");

    return 1;
}


char **init_array(void)
{
    char **array = malloc(sizeof(char *));
    array[0] = NULL;
    return array; 
}


char **add_string(char **array, const char *string)
{
    char** cache = array;
    unsigned int size = 0;
    while (*array) {
        size++;
        array++;
    }

    char **newarr = (char **)realloc(cache, sizeof(char *) * (size + 2));

    newarr[size] = malloc(strlen(string)+1);
    strcpy(newarr[size], string);
    newarr[size+1] = NULL;

    return newarr;
}

Another note - main function should return 0 on success.