How to create variable size array that contains strings?

Maybe something like this. It will grow the size of the array when you add new types. It will also keep track of how many types you have in the array (it is needed if you resize the array dynamically and you need to know how many elements are in this array).

#define AUDIO_TYPE_LENGTH 40

typedef char audio_type[AUDIO_TYPE_LENGTH];

typedef struct
{
    size_t size;
    audio_type audio_types[];
}audioTypes_t;

audioTypes_t *AddType(audioTypes_t *types, const char *type)
{
    size_t size = types ? types -> size : 0;

    types = realloc(types, sizeof(*types) + (size + 1) * sizeof(types -> audio_types[0]));

    if(types)
    {
        strncpy(types -> audio_types[size], type, sizeof(types -> audio_types[0] - 1));
        types -> audio_types[size][sizeof(types -> audio_types[0] - 1)] = 0; //making strncpy safe
        types -> size = size + 1;
    }
    return types;
}

You cannot change the size of an array in C. You could create a new array each time you want to resize and transfer the contents from the old array to the new one. Alternatively, you could use a list to store your strings.

char string[40] is an array of 40 characters that can hold 39 characters maximum (plus the string terminator) - the maximum size cannot be changed and 40 bytes of memory are used even if you store a short string containing 2 characters (plus the string terminator).

char *string is a pointer to some characters - the pointer can point anywhere: to a single character or any size array of characters. If it points to an array of characters (which you can make using malloc() then it can be thought of as a "string")

char *array[8] is an array of 8 "strings" (really it is 8 pointers to characters) The size of the array cannot be changed but the pointers can point anywhere: to a single character or any size array of characters. If the pointers point to an array of characters (which you can make using malloc() then they can be thought of as "strings")

char array[8][40] is a 2D array which you can think of as an array of 8 "strings" - where "strings" is defined as an array of 40 characters that can hold 39 characters maximum (plus the string terminator). You cannot change the size of either dimension.

char **array is a pointer to a char * - which could just be a single "string" or to an array of "strings". The sizes aren't fixed and can be dynamically created.

char *string1 = "asd"; means that string1 points to an array of 4 characters ("asd" plus the string terminator) that are in read-only memory - you cannot change the contents of the string but you can point string1 anywhere you want.

char string1[] = "asd"; means that string1 is an array of 4 characters that are filled up by the compiler with 4 characters ("asd" plus the string terminator) - you can change the contents of the array but you can't change the size.

So if you want a dynamically sized array of character strings you can do this:

#include <stdio.h>  // printf
#include <stdlib.h> // malloc, realloc, free
#include <string.h> // strcpy, strdup

int main()
{
    // make an array of 8 string pointers
    int original_size = 8;
    char **array = malloc(original_size * sizeof(char *));
    
    // point each pointer to a string
    // you don't have to do this all at once if you don't want to
    for (int i=0; i<original_size; i++)
        array[i] = malloc(40 * sizeof(char)); // max of 39 plus the terminator
    
    // array[7] is already allocated so we can just use it as a string
    strcpy(array[7],"asd"); // the last string that we malloced
    
    // reallocate the array to be bigger
    int new_size = 15;
    array = realloc(array, new_size * sizeof(char *));

    // array[14] is a pointer that doesn't point anywhere
    // so we need to allocate space before filling it in
    array[14] = strdup("qwe"); // points 3 characters plus the string terminator
    
    printf("%s\n",array[7]);
    printf("%s\n",array[14]);
    
    // free the one we made with strdup
    free(array[14]);
    
    // free the 8 we malloced
    for (int i=0; i<original_size; i++)
        free(array[i]);
    
    // now free the array we malloced and then realloced
    free(array);
    
    return 0;
}

Note: there is NO error checking in that program because I didn't want to mask the basic ideas - make sure you add error checking to any program you make

Try it at https://onlinegdb.com/XQeyOGd0C

When you define the array ( the char *audio_types[40]; line) in C it creates a contiguous block of memory to the 40 char pointers in the array. As memory is allocated when the array is defined you cannot make the array longer. To do that you would need a List data type, or you could create a new array when you want to add a new element which is the old one with the new element at the end.