Dynamically store lines of strings using C

There are several data structures that allow you to add items dynamically, without having to know in advance what the maximum number of elements required are. There are linked lists, binary search trees, balanced trees, tries, heaps and many more.

Similarly, there are lots of ways of dynamically allocating strings of different lengths.

The easiest way would probably be to use a simple linked list:

typedef struct _node {
    struct _node *next;
    char *value;
} node_t;

You keep track of the head, the first item in the list, and each next field points to the next node in the list. For example, to traverse the list, you would write something like this:

currentNode = head;
while(currentNode != NULL) {
    /* do something with currentNode->value */
    currentNode = currentNode->next;
}

Without knowing what you want to do, specifically, I can't really offer any better suggestions.

What operations do you want to carry out on your data structure often? Are you going to simply be iterating through the strings, searching for strings, adding and removing strings?

There are several data structures that allow you to grow dynamically. As the 2 previous replies suggest, you can use an array of pointers, a linked-list etc.

It all depends on the requirements of your implementation:

1. Will you be accessing those strings more than once?
2. Once you obtain them, do you intend to access them all (for some calculation) or one at a time (i.e. a dictionary)?
3. What are your space/memory consideration?
4. Is there any importance to the order in which you get them (suggesting a queue or a stack implementation)?
5. Is there an inherent connection between the strings (suggesting a tree or tree-like structure)?

etc. I suggest reading a bit about data structures and deciding what suits you best. They can all be implemented in C.
Look at this Wikipedia article (go to the 'Examples' section for a list of options, if you want to skip the theory)

If you know at some initialization time the number of strings and will not need to allocate for more, you could just use a:

char **myStrings = (char **)malloc(numStrings*sizeof(*myStrings);

and then allocation for each string:

for(int i=0; i<numStrings; i++)
    myStrings[i] = (char *)malloc(stringLength[i] + 1);

You could still allocate more dynamically if needed, though.

If you need to dynamically reallocate the array of strings:

myStrings = (char **)realloc(myStrings, numStringsNew*sizeof(myStrings));

or if a particular string needs to change its length, just realloc that particular string:

myStrings[the_one_to_realloc] = (char *)realloc(myStrings[the_one_to_realloc], stringLengthNew + 1);

Run, don't walk, to the Princeton web site and get Dave Hanson's C Interfaces and Implementations. The data structure called Seq_T is perfect for building up a list of lines dynamically. Dave doesn't provide a buffering reader, but you can read lines into a finite buffer, convert the result using Text_put, and if a line is too big for one buffer, join the results using Text_cat. The CII code manages all the dynamic growth for you.

There is little reason to reinvent the wheel, unlike what some answers suggest.

Do not develop your own library, while there are several free software libraries which implement such abstractions. One example, among others, is glib which has many types such as dynamically growing strings and dynamically growing lists.

To store dynamically, use can use the 'm' flag of %s as shown below:

char *variable;
scanf ("%ms", &variable);
/* use variable */
free(variable);

The string pointed by variable will be sufficient to hold the data.

Do note, that it is your responsibility to free the variable after its use.