changing fixed size array to dynamic in C

As your question title says C, IMO the best approach will be to decalre a pointer of that particular variable type in your main() function, pass the address of that pointer [essencially a double-pointer] to other functions and allocate memory dynamically.

You can keep on passing the pointer to all other functions. Inside every called functions, measure the amount of memory required to put the data [from that particular function] and use realloc() to increase the available memory.

^{As mentioned by UncleO, the required pointer should be the pointer to array [i.e, a double pointer]}

EDIT

1. For the very first time allocating memory to that pointer, you can use malloc() or calloc().

2. From next time onwards, to extend [resize] the amount of memory, you need to use realloc()

You don't pass an array to a function in C, although it appears that way. What gets passed is a pointer to the first element of the array. The pointer is passed by value. That is, the value of the pointer (the memory location) is copied into a local variable. The contents of the array can be changed using this local variable.

If you use malloc() or realloc() with this local variable, then the pointer that was "passed in" won't be affected. realloc() may resize the memory, but it can also free that memory and allocate some new memory to the local variable.

If you want to change the array pointer, then you should pass in a pointer to the pointer. The thing the pointer points to is what is changed. This is a bit more cumbersome. But this way you can allocate more memory is needed.

#include <stdlib.h>    

char* arr;

void changeit(char** arrptr)
{
    *arrptr = realloc(*arrptr, 20*sizeof(char));
}

void main (void)
{
    arr = malloc(10*sizeof(char));

    changeit(&arr);
}

To function that do not alter the array, pass the array address and size.

int foo1(const char *array, size_t size, ...)

To each function that does not change the array size, pass array address and array size

int foo2(char *array, size_t size, ...)

To functions that may alter the array size, pass the address of the address of the array and the address of the size.

int foo3(char **array, size_t *size, ...)

Code could put these two variables together

typedef struct {
  size_t size;
  char array;
} YetAnotherArrayType;

Chux,

There's a little typo at then end of your post. I think you mean:

typedef struct {
  size_t size;
  char* array;
} YetAnotherArrayType;

You didn't make array a pointer type.

If the poster is handcrafting a container, the classic solution is to track both a size and a capacity. In that model you allocate the array to some initial a capacity and set size to 0. You then track its population causing it grow by some chunk size or factor each time it fills up. Frequent reallocation can be a massive performance drain and by the sounds of the program in question such behaviour seems likely.