How to create an array of arrays in C when the number of subarrays is not specified?

Question

I am trying to create an array of arrays but the the number of subarrays is unknown.

Answer 1

Jagged array is array of arrays such that member arrays can be of different sizes, i.e., we can create a 2-D array but with a variable number of columns in each row.

Static Jagged Array:

int kk0[4] = { 1, 2, 3, 4 };  
int kk1[2] = { 5, 6 }; 
int* jagged[2] = { kk0, kk1 }; 

Dynamic Jagged Array:

 int* jagged[2]; 
 jagged[0] = malloc(sizeof(int) * 1); 
 jagged[1] = malloc(sizeof(int) * 3); 

Reference : https://en.wikipedia.org/wiki/Jagged_array

Answer 2

"create an array of arrays but the the number of subarrays is unknown."

If using C99, or a compiler since then that supports variable length arrays (optional since C11), this would provide a way to do this at run-time. A short example:

#define ARRAY_BASE_SIZE 20 //known at compile time

int main()
{
    int numSubArrays = 0; 
    printf("enter a value for number of sub-arrays:\n");
    int count = scanf("%d", &numSubArrays);//not known until run-time
    if(count == 1)
    {
        int array[ARRAY_BASE_SIZE][numSubArrays];
        memset(array, 0, sizeof(array)); 
    }
    
    return 0;
}

Answer 3

If the number of sub arrays is not known then the array must be expandable when there are more sub arrays than you thought.

int **myArrays;        // the array of arrays
int nSubArrays= 0;     // its current size
int nUsed= 0;          // how many have been used
#define INCREMENT 5    // increment for alocation

myArrays= malloc(sizeof(int *) * INCREMENT);
nSubArrays= INCREMENT;
nUsed= 0;

now fill the array(s):

myArrays[nUsed]= fillSubArray();
nUsed++;

and expand the array when it becomes full:

if (nUsed==nSubArrays) {
    int **tmp= realloc(myArrays, sizeof(int *)*(nSubArrays+INCREMENT));
    if (!tmp) return 0; // error
    myArrays= tmp;
    nSubArrays += INCREMENT;

Answer 4

In C it is very common practice to declare a pointer and reference it as an array. In C an array will decay to a pointer when the reference of the array is assigned to the pointer. To reference an array of arrays, it is common to declare a pointer-to-pointer, assign it to the reference of a 2-D array, and later index it like a 2-D array.

The following are all equivalent. argv is an array of array of char. Using [] makes your intention of using indexing a pointer as an array clear to other programmers who might be reading your code.

char **argv;
char *argv[];

char argv[][]; (this is wrong)

The size of the array is usually communicated separately. In fact, the parameters of the main function does just that. When you see

int main(int argc, char *argv[]);

The char *argv[] is an array of array of characters (aka array of strings) passed from the command line. The argument argc represents the number of arrays in argv. To index the first element in the array, use argv[0], whose type is will be char* (aka char[]).

Answer 5

How about this, its just an attempt to give a start point, not the complete answer, but we can build on this.

Also we need to keep track of size of each subarray to access valid locations, am sure that can be done easily by some kind of book keeping.

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

#define BASE_SIZE 3

int main()
{
    int** dyn_array = NULL;
    int countSubArray  = 0;
    int count = 0;
    int size = 0;
    
    dyn_array = malloc(sizeof (int* ) * BASE_SIZE);
    if ( dyn_array ) {
        printf("enter number of subarrays:");
        scanf("%d", &countSubArray);
        while( count < countSubArray) {
            printf("enter sizeof %d subarray", count+1);
            scanf("%d", &size);
            if ( dyn_array[count] = malloc(sizeof (int) * size) )
            {
                printf("Allocated sub array %d at %p\n",count+1, (void*) dyn_array[count]);
            }
            count++;
        }
    }
    return 0;
}