Dynamically allocated 2 dimensional array

Question

I am trying to build two dimensional array by dynamically allocating. My question is that is it possible that its first dimension would take 100 values, then second dimension would take variable amount of values depending on my problem? If it is possible then how I would access it? How would I know the second dimension's boundary?

Answer 1

(See the comments in the code)

As a result you'll get an array such like the following:

// Create an array that will contain required variables of the required values
// which will help you to make each row of it's own lenght.
arrOfLengthOfRows[NUMBER_OF_ROWS] = {value_1, value_2, ..., value_theLast};

int **array;
array = malloc(N * sizeof(int *));   // `N` is the number of rows, as on the pic.

/*
if(array == NULL) {
    printf("There is not enough memory.\n");
    exit (EXIT_FAILURE);
}
*/

// Here we make each row of it's own, individual length.
for(i = 0; i < N; i++) {
    array[i] = malloc(arrOfLengthOfRows[i] * sizeof(int)); 

/*
if(array[i] == NULL) { 
    printf("There is not enough memory.\n");
    exit (EXIT_FAILURE);        
}
*/
}

Answer 2

You can use array of 100 pointers:

int *arr[100];

then you can dynamically allocate memory to each of the 100 pointers separately of any size you want, however you have to remember how much memory (for each pointer) you have allocated, you cannot expect C compiler to remember it or tell it to you, i.e. sizeof will not work here.

To access any (allowed, within boundary) location you can simply use 2D array notation e.g. to access 5th location of memory allocated to 20th pointer you can use arr[20][5] or *(arr[20] + 5).

Answer 3

I believe the OP wants a single chunk of memory for the array, and is willing to fix one of the dimensions to get it. I frequently like to do this when coding in C as well.

We all used to be able to do double x[4][]; and the compiler would know what to do. But someone has apparently messed that up - maybe even for a good reason.

The following however still works and allows us to use large chunks of memory instead of having to do a lot of pointer management.

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

// double x[4][];

struct foo {
    double y[4];
} * x;

void
main(int ac, char * av[])
{
    double * dp;
    int max_x = 10;
    int i;

    x = calloc(max_x, sizeof(struct foo));
    x[0].y[0] = 0.23;
    x[0].y[1] = 0.45;
    x[9].y[0] = 1.23;
    x[9].y[1] = 1.45;

    dp = x[9].y;
    for (i = 0; i < 4; i++)
        if (dp[i] > 0)
            printf("%f\n", dp[i]);
}

The trick is to declare the fixed dimension in a struct. But keep in mind that the "first" dimension is the dynamic dimension and the "second" one is fixed. And this is the opposite of the old way ...

You will have to track the size of your dynamic dimension on your own - sizeof can't help you with that.

Using anonymous thingies you might even be able to git rid of 'y'.

Answer 4

Using a single pointer:

int *arr = (int *)malloc(r * c * sizeof(int));

/* how to access array elements */

for (i = 0; i <  r; i++)
  for (j = 0; j < c; j++)
     *(arr + i*c + j) = ++count;  //count initialized as, int count=0;

Using pointer to a pointer:

int **arr = (int **)malloc(r * sizeof(int *));
for (i=0; i<r; i++)
     arr[i] = (int *)malloc(c * sizeof(int));

In this case you can access array elements same as you access statically allocated array.