Initialize 2-D array of unknown size

Question

I have a 2-D array of characters e.g. char aList[numStrings][maxLength]. ideally, during program execution I want to be able to modify the contents of aList i.e. add, amend or delete entries. Since aList will be subject to change, I don't want to have to recompile my program after every such change to modify aList. So I want to write aList out to a text file at program end and then read it back into aList at the commencement of the next program run.

However, I don't know at program start what is the value of numStrings. (I am not using C99 so I can't use a VLA, and pick up a count of previous strings from an external file.) I could, of course, set numStrings to an artificially high value but that grates!

Is there a way to populate aList without knowing the value of numStrings? I don't think there is (I have looked at related questions) but is there another way of achieving what I need?

Answer 1

You can dynamically allocate the array:

char **aList;
int i;

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

for (i = 0; i < maxLength; i++)
{
    aList[i] = malloc(maxLength);
}

If, by any chance, you can use C++ instead of C, you could always use a C++ vector:

std::vector<std::vector<char> > aList;

Answer 2

The situation you've described is precisely what malloc is for -- allocating a variable-length block of memory.

Answer 3

If your plan is to populate while reading in the file you could do one of two things.

Either store the number of strings as the first element in the file, then the suggestion by jgottula would work well.

Or, must you use an array? You could read them directly into a linked list, and then when finished reading, move them into an array, and free up the linked list.

Answer 4

You could use a dynamically allocated array. Use malloc() to make one, realloc() to change the size of one, and free() when you're done with it. But this has already been covered by another answer.

Another alternative is to use a linked list. That way you don't have to realloc() every time you want to extend your array - realloc() can be rather expensive if it has to copy the entire array to a new location.

Answer 5

If you really want to be able to remove items from the middle of the grid (your questions isn't clear on this), you'll need some kind of multiply linked structure. These are often used to implement sparse arrays, so you can probably find one pre-made.

I'm talking about something like this:

+---+  
| A |  
+-|\+  
  | \  
  |  \  
  |   \  
  |    \
  |     +----+----+----+  
  |     | C0 | C1 | C2 | ...  
  |     +--|-+----+--|-+  
  |        |         |
  |        |         |  
+-V--+  +--V-+       | +----+
| R0 |->|a0,0|-------+>|a0,3|--> ...
+----+  +--|-+    +--V-+----+
| R1 |-----+----->|a1,2|--> ...
+----+     |      +--|-+
 ...       V         |
          ...        V
                    ...

Where A is the root node of the object, C is an array of column pointers, R is an array of row pointers, and each cell points to it next neighbor along both its row and column. All cells not explicitly represented are assumed to have some default value (usually NULL or 0).

It is a simple idea, but a fairly picky implementation, with lots of chances to mess up, so use a debugged library if you can.