You should assign an array of char pointers, and then, for each pointer assign enough memory for the string:

char **orderedIds;

orderedIds = malloc(variableNumberOfElements * sizeof(char*));
for (int i = 0; i < variableNumberOfElements; i++)
    orderedIds[i] = malloc((ID_LEN+1) * sizeof(char)); // yeah, I know sizeof(char) is 1, but to make it clear...

Seems like a good way to me. Although you perform many mallocs, you clearly assign memory for a specific string, and you can free one block of memory without freeing the whole "string array"

You can ask user to separate names with comma or space or some other delimiter. You can find strchr() function useful for parsing names in such an input.

Another option is to ask further names in a loop by saying press y(or some character) to add another name.

NOTE: My examples are not checking for NULL returns from malloc()... you really should do that though; you will crash if you try to use a NULL pointer.

First you have to create an array of char pointers, one for each string (char *):

char **array = malloc(totalstrings * sizeof(char *));

Next you need to allocate space for each string:

int i;
for (i = 0; i < totalstrings; ++i) {
    array[i] = (char *)malloc(stringsize+1);
}

When you're done using the array, you must remember to free() each of the pointers you've allocated. That is, loop through the array calling free() on each of its elements, and finally free(array) as well.

The link in the comments above [mostly] assumes that we know the number of elements before we allocate the array.

Thus, it's not as useful when we can only get the number of elements by reading the input file. For TTY input from stdin this won't work too well because we can't rewind the file.

A dynamic array is generally useful. So, I've created one that allows arbitrarily sized array elements. And, it can grow/expand as we add new elements.

And, for demo purposes here, I've created a "book" structure that stores Author's name and book title.

Here is the code. It is annotated:

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

// general dynamic array control
typedef struct {
    void *arr_base;                         // pointer to data
    size_t arr_size;                        // bytes / element
    size_t arr_count;                       // number of elements in use
    size_t arr_capacity;                    // number of elements allocated
} arr_t;

// book control
typedef struct {
    char *book_last;                        // author's last name
    char *book_first;                       // author's first name
    char *book_title;                       // book title
} book_t;

// arrnew -- allocate new array
arr_t *
arrnew(size_t siz)
{
    arr_t *arr = calloc(1,sizeof(*arr));

    // store the number of bytes in each element
    arr->arr_size = siz;

    return arr;
}

// arrappend -- get new element in array
// RETURNS: pointer to element
void *
arrappend(arr_t *arr)
{
    size_t index;
    void *ptr;

    // get index of element to store into and increase the in use count
    index = arr->arr_count++;

    do {
        // we have enough space for the new element already
        if (arr->arr_count < arr->arr_capacity)
            break;

        // increase allocated amount
        // NOTE: the increment is arbitrary
        arr->arr_capacity += 10;

        // grow the array
        arr->arr_base = realloc(arr->arr_base,
            arr->arr_capacity * arr->arr_size);

        // got the larger array
        if (arr->arr_base != NULL)
            break;

        perror("arrappend");
        exit(1);
    } while (0);

    // point to element we can store into
    ptr = arr->arr_base;
    ptr += index * arr->arr_size;

    return ptr;
}

// arrtrim -- trim array to number of elements actually used
void
arrtrim(arr_t *arr)
{

    arr->arr_capacity = arr->arr_count;
    arr->arr_base = realloc(arr->arr_base,arr->arr_capacity * arr->arr_size);

    if (arr->arr_base == NULL) {
        perror("arrtrim");
        exit(1);
    }
}

// arrfree -- free up array storage
void
arrfree(arr_t *arr)
{

    free(arr->arr_base);
    free(arr);
}

int
main(void)
{
    char buf[300];
    char *cp;
    book_t *book;

    // echo line if input is _not_ a tty [mostly for demo]
    struct termios tio;
    int echo = tcgetattr(fileno(stdin),&tio) < 0;

    // get new array
    arr_t *arr = arrnew(sizeof(book_t));

    printf("Gimme Books's Titles:\n");

    while (1) {
        // get next line -- stop on EOF
        char *cp = fgets(buf,sizeof(buf),stdin);
        if (cp == NULL)
            break;

        // echo line if input is _not_ a tty
        if (echo)
            fputs(buf,stdout);

        // strip newline
        buf[strcspn(buf,"\n")] = 0;

        // stop on blank line
        if (buf[0] == 0)
            break;

        // get new book struct
        book = arrappend(arr);

        // get author's last name
        char *tok = strtok(buf," \t");
        book->book_last = strdup(tok);

        // get author's first name
        tok = strtok(NULL," \t");
        book->book_first = strdup(tok);

        // get the book title
        tok += strlen(tok);
        ++tok;
        for (;  *tok != 0;  ++tok) {
            if (*tok != ' ')
                break;
        }
        book->book_title = strdup(tok);
    }

    arrtrim(arr);

    // show all the books
    book = arr->arr_base;
    for (size_t idx = 0;  idx < arr->arr_count;  ++idx, ++book)
        printf("Last: %s First: %s Title: %s\n",
            book->book_last,book->book_first,book->book_title);

    // release storage for each book
    book = arr->arr_base;
    for (size_t idx = 0;  idx < arr->arr_count;  ++idx, ++book) {
        free(book->book_last);
        free(book->book_first);
        free(book->book_title);
    }

    // release array storage
    arrfree(arr);

    return 0;
}

Here is the program input:

Lambstewer Abel A Tale of Two Cities
Smith John      A baker's tale
Jones Fred      Never On Sunday

Here is the program output:

Gimme Books's Titles:
Lambstewer Abel A Tale of Two Cities
Smith John      A baker's tale
Jones Fred      Never On Sunday
Last: Lambstewer First: Abel Title: A Tale of Two Cities
Last: Smith First: John Title: A baker's tale
Last: Jones First: Fred Title: Never On Sunday

You can allocate an array of arbitrary length with malloc() (it's like "new" in Java), and make it grow or shrink with realloc().

You have to remember to free the memory with free() as in C there is not garbarage collector.

Check: http://www.gnu.org/software/libc/manual/html_node/Memory-Allocation.html#Memory-Allocation

Edit:

#include <stdlib.h>
#include <string.h>
int main(){
    char * string;
    // Lets say we have a initial string of 8 chars
    string = malloc(sizeof(char) * 9); // Nine because we need 8 chars plus one \0 to terminate the string
    strcpy(string, "12345678");

    // Now we need to expand the string to 10 chars (plus one for \0)
    string = realloc(string, sizeof(char) * 11);
    // you can check if string is different of NULL...

    // Now we append some chars
    strcat(string, "90");

    // ...

    // at some point you need to free the memory if you don't want a memory leak
    free(string);

    // ...
    return 0;
}

Edit 2: This is the sample for allocate and expand an array of pointers to chars (an array of strings)

#include <stdlib.h>
int main(){
    // Array of strings
    char ** messages;
    char * pointer_to_string_0 = "Hello";
    char * pointer_to_string_1 = "World";
    unsigned size = 0;

    // Initial size one
    messages = malloc(sizeof(char *)); // Note I allocate space for 1 pointer to char
    size = 1;

    // ...
    messages[0] = pointer_to_string_0;


    // We expand to contain 2 strings (2 pointers really)
    size++;
    messages = realloc(messages, sizeof(char *) * size);
    messages[1] = pointer_to_string_1;

    // ...
    free(messages);

    // ...
    return 0;
}