Thread: I want a dynamic array.

Based on my last series of posts which you needn't read, I now need a new method of creating a dynamicly expanding global array. I suspect I won't get one, which would be COMPLETELY RIDICULOUS and makes me wonder how anyone has managed to do anything significant in C at all.

Here's the issue: I want to read in a text file consisting of lines like this
bob 3874 habit
scram 9984 sweater
flux 12 then
so each line ends up in a struct like this:

Code:

struct info {
     char *name;
     int *num;
     char *also;
} ray[3];

However, the number of such lines is indeterminate, so "ray[3]" won't work. This must be a common task. How can I create an array of structs that will grow when I add a new entry, so to speak? Or do I have to (COMPLETELY RIDICULOUS) have to just set ray[10000] or something, to make sure I have enough space?

How can I create an array of structs that will grow when I add a new entry, so to speak?

Use malloc() and free() from <stdlib.h>, e.g.,

Code:

#include <stdlib.h>

struct info {
    char *name;
    int *num;
    char *also;
};

int main(void) {
    struct info *ray;
    ray = malloc(3 * sizeof(*ray));
    /* Use ray[0], ray[1] and ray[2] here. */
    free(ray);
    return 0;
}

Though in the above example we do not actually expand the array, but that can be done with realloc(), also declared in <stdlib.h>.

Or do I have to (COMPLETELY RIDICULOUS) have to just set ray[10000] or something, to make sure I have enough space?

That is actually an option: if you have a small enough upper limit of the number of elements, then you might decide to create an array of that size and just use as much of it as is needed.

EDIT:
Gah, it looks like the tutorials and FAQs here only touch on dynamic memory allocation with respect to C++. Anyway, search the Web and you will find more info. Also, you might note that my example does not include checking the return value of malloc() for NULL, but checking whether the allocation failed is good practice.

malloc and realloc will do! I just didn't see how to use them with an array...thanks.

phew! I thot i was crazy.

hmmm...what's "fuel efficiency" about here: the awkwardness of having to use realloc, or the expense of learning C++ when I just rolled C off the lot last month...

I gotta thank kpreston, actually, as I have saved his refs for later. But right now a simple malloc suffices (the array doesn't really need to grow, but its initial size is a variable, and the struct must be global).

It didn't occur to me to use sizeof that way; up to now the only (error checked) malloc calls I've made have been simple character arrays, and multipying by 1 is easy.

I think the reason I started to write this was that I thot master5001 might have some deeper performance issues in mind. Now I'm not so sure.

I gotta thank kpreston, actually, as I have saved his refs for later.

Be warned that the first article may appear much simpler than the second, but the example given fails to free the memory allocated. The second article is much more comprehensive, but perhaps a little more intimidating.

I think the reason I started to write this was that I thot master5001 might have some deeper performance issues in mind. Now I'm not so sure.

Do you need to quickly add elements in the middle? If so, consider a linked list. Do you need to quickly access elements anywhere? If so, consider an array-like structure like a vector. Expanding a linked list from the middle (assuming that you already have a pointer to the insertion point) takes constant time, but expanding a dynamic array from the middle takes linear time (but expanding it from the end also takes constant time, in the long run, if you double the allocation whenever you need to expand). On the other hand, accessing the middle of a linked list takes linear time if you start from the head, while arrays have random access.

Realloc example:

Code:

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

#define LINE_BUF_SZ 1024
static const unsigned int RAY_CHUNK_SIZE = 10;

typedef struct _info
{
   char *name;
   int num;
   char *also;
} info;

void print_data(const info **data, const unsigned int count)
{
   unsigned int i = 0;
   for ( ; i < count; ++i)
   {
      printf("Entry %u: %s %d %s\n", i,
            data[i]->name, data[i]->num, data[i]->also);
   }
}

void free_data(info **data, const unsigned int count)
{
   unsigned int i = 0;
   for ( ; i < count; ++i)
   {
      free(data[i]->name);
      free(data[i]->also);
      free(data[i]);
   }
}

int main()
{
   char line[LINE_BUF_SZ];
   char temp_name_buf[LINE_BUF_SZ], temp_also_buf[LINE_BUF_SZ];
   FILE *fp = fopen("dyndata.txt", "r");
   if (!fp)
      return -1;

   unsigned int ray_count = RAY_CHUNK_SIZE;
   info **ray = calloc(ray_count, sizeof(*ray));
   if (!ray)
      return -1;

   unsigned int line_count = 0;
   while(NULL != (fgets(line, sizeof(line), fp)))
   {
      if (line_count + 1 == ray_count)
      {
         // Need realloc                                                         
         info ** temp = realloc(ray, (ray_count += RAY_CHUNK_SIZE) * sizeof(*ray));
         if (!temp)
         {
            free_data(ray, line_count);
            free(ray);
            return -1;
         }
         ray = temp;
      }

      ray[line_count] = calloc(1, sizeof(info));
      if (!ray[line_count])
         return -1;

      if (3 != sscanf(line,
                      "%s %d %s",
                      temp_name_buf,
                      &ray[line_count]->num,
                      temp_also_buf))
      {
         return -1;
      }

      ray[line_count]->name = strdup(temp_name_buf);
      ray[line_count]->also = strdup(temp_also_buf);
      ++line_count;
   }

   print_data((const info **)ray, line_count);

   free_data(ray, line_count);
   free(ray);

   fclose(fp);

   return 0;
}