Make pointer to multidimensional array in C without knowing dimensions

Question

Let's say I have a pointer

char *p;

in my main function I have a multidimensional array a:

char a[10][15];

I want p to point to a and to be able to use p[x][y] to refer to values in the array. I thought p = a; would normally take care of this but I got a cast error.

p = &a[0][0];

makes the new pointer but sees it as a one-dimensional array of chars. Any way to make the pointer see the array as two-dimensional?

Note that when I define p I do not know the dimensions of a yet.

Answer 1

The declaration

char * p;

makes p a pointer to an object of type char, or to the first element of an array of objects of type char.

You want to declare a pointer to an array of 15 chars, or to the first element of an array of arrays of 15 chars:

char (* p) [15];

Now you can say

p = a;

And access the elements of a through p.

Answer 2

If you don't know the dimensions of a. You need a jagged array. That is another array that stores the address of every sub-array.

char a1[10];
char a2[20];
char a3[30];
char* jagged[3] = {a1, a2, a3};
char** p = jagged;

But the overhead of another array is probably not what you want.

Without the jagged array you'll have to know at least the second dimension of the array to locate the element you want. For your array a[10][15], to locate the element a[x][y], the code get the offset of that element by calculating x * 15 + y. Note the 15 in that expression, it's the second dimension of the 2d array.

Answer 3

C offers no mechanism to pass the dimensions of variable-sized multidimensional arrays around. You have to implement it yourself, i.e. you have to come up with your own type that means int array[10][20]. For example, in the (untested) code below, you can pass around an int_array *, and use int_at to get the value. You can also inspect the dimensions within int_array, etc. The code using the int_array * doesn't even need to know how many dimensions it has got.

vint_ptr_at is doing, pretty much, what the compiler-generated code would do to compute the address, although that code can be optimized better than the generic version. Normally, if you were to iterate, you could use the int* you got from int_ptr_at, and keep incrementing it.

#include <assert.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>

typedef struct {
  int *data;
  int num_dims;
  bool owns_data;
  struct {
    size_t count, product;
  } dims[1];
} int_array;

void free_int_array(int_array *arr) {
  if (arr && arr->owns_data) free(arr->data);
#ifdef DEBUG
  arr->data = NULL;
#endif
  free(arr);
}

static bool int_array_setup_dims(int_array *arr, va_list args) {
  size_t n = 1;
  int const num_dims = arr->num_dims;
  for (int i = 0; i < num_dims; i++) {
    int dim = va_arg(args, int);
    arr->dims[i].count = dim;
    arr->dims[num_dims - 1 - i].product = n;
    if (n > SIZE_MAX / dim) return false;
    n *= dim;
  }
  return true;
}

int_array *vnew_int_array_on(void *data, int num_dims, va_list args) {
  int_array *arr = malloc(sizeof(int_array) + (num_dims-1)*sizeof(int));
  if (!arr) goto fail;
  arr->num_dims = num_dims;
  if (!int_array_setup_dims(arr, args)) goto fail;

  arr->data = data ? data : malloc(n * sizeof(int));
  arr->num_dims = num_dims;
  arr->owns_data = !data;
  if (!arr->data) goto fail;
  return arr;
fail:
  free(arr);
  return NULL;
}

int_array *new_int_array(int num_dims, ...) {
  va_list args;
  va_start(args, num_dims);
  int_array *arr = vnew_int_array_on(NULL, num_dims, args);
  va_end(args);
  return arr;
}

int_array *new_int_array_on(void *data, int num_dims, ...) {
  va_list args;
  va_start(args, num_dims);
  int_array *arr = vnew_int_array_in(data, num_dims, args);
  va_end(args);
  return arr;
}

int *vint_ptr_at(const int_array *arr, va_list args) {
  size_t index = 0, n = 1;
  int const num_dims = arr->num_dims;
  for (int i = 0; i < num_dims; i++) {
    int j = va_arg(args, int);
    index += j * arr->dims[i].product;
  }
  return arr->data + index;
}

int *int_ptr_at(const int_array *arr, ...) {
  va_list args;
  va_start(args, arr);
  int *ptr = vint_ptr_at(arr, args);
  va_end(args);
  return ptr;
}  

int int_at(const int_array *arr, ...) {
  va_list args;
  va_start(args, arr);
  int *ptr = vint_ptr_at((int_array*)arr, args);
  va_end(args);
  return *ptr;
}

size_t *indices_for(const int_array *arr) {
  if (!arr) return NULL;
  size_t const size = sizeof(size_t) * arr->num_dims;
  size_t *indices = malloc(size);
  if (indices) memset(indices, 0, size);
  return indices;
}

bool next_index(const int_array *arr, size_t *indices) {
  for (int i = arr->num_dims - 1; i >= 0; i--) {
    if (indices[i] < arr->dims[i].count) {
      indices[i] ++;
      return true;
    }
    indices[i] = 0;
  }
  return false;
}

int main() {
  int data[10][15];
  int_array *arr = new_int_array_on(data, 2, 10, 15);
  assert(arr->dims[0].dim == 10);
  assert(arr->dims[1].dim == 15);
  data[2][3] = 40;
  data[4][5] = 50;
  data[5][6] = 100;
  assert(int_at(arr, 2, 3) == 40);
  assert(int_at(arr, 4, 5) == 50);
  assert(int_at(arr, 5, 6) == 100);
  free_int_array(arr);
}

#include <stdio.h>

void iteration_example(const int_array *arr) {
  size_t *indices = indices_for(arr);
  if (indices) {
    int *data = arr->data;
    do {
      printf("arr");
      for (int i = 0; i < arr->num_dims; ++i)
        printf("[%zd]", indices[i]);
      printf(" = %d\n", *data++);
    } while (next_index(arr, indices));
  }
  free(indices);
}