In C/C++: How can i implement a 2D int array using two single pointers (no use of **int)?

Question

I am exploring pointer "mechanics" in C/C++. I try to understand if and how is possible to implement a 2D matrix using two pointers (one for "rows" and one for "columns") instead of a single double pointer. I am aware that a matrix with rows*columns number of values could be stored in memory sequentially, but i am looking to comprehend deeper the mechanics of pointers and eventually to implement a function similar to

int value=getValue(vectorNr,vectorValue) 

that is able to "simulate" the construct

value=Matrix[vectorNr][vectorValue]

vectorPointer                 vectorValue
| AddressV1 |------|valAddr11 valAddr12 valAddr13 |
| AddressV2 |------|valAddr21 valAddr22 valAddr23 |
| AddressV3 |------|valAddr31 valAddr32 valAddr33 |   

I tried to begin writing a code like this but I quickly get stuck on pointer arithmetic and address offsetting. I also might chose a very dirty approach so any comment is welcome.

CODE TO IMPLEMENT A 2D ARRAY WITH POINTERS (BUT NOT USING DOUBLE POINTERS). To avoid confusion between rows and columns I refer to "Vectors as rows" and "Columns as vector values"

    int vectorsNumber = 3; //Number of Vectors
    int valuesNumber = 3; //Number of values stored in one     Vector


    //Addresses of Vectors. Since Vectors holds a reference to set of values, vectorPointer will hold an address for every set.
    void* vectorPointer = malloc(vectorsNumber     *sizeof(void*)); 


    //Populating the vectorPointer with the address generated by allocating memory for every set of values
    for (int i = 0; i < vectorsNumber; i++)
    {
        vectorPointer = (int*)malloc(valuesNumber * sizeof(int)); //Values shall be of int types
        vectorPointer++; //ILLEGAL since cannot perform arithmetic on pointers of type void. What do do??
    }

    //Restore the initial address. In any case...ILLEGAL arithmetic.    What do do??
    for (int i = 0; i < vectorsNumber; i++)
    {
        vectorPointer--; //Restore the initial address. In any case...ILLEGAL arithmetic.
    }

    //Declaring the pointer to hold the address of one value. Memory was already allocated before
    int* valueAddress; 
    for (int j = 0; j < vectorsNumber; j++)
    {
        //Getting the address of the first value of the first Vector
        valueAddress = (int*)vectorPointer; //Is this casting valid in C language?


        //Populating the value with whatever operation
        for (int k = 0; k < valuesNumber; k++)
        {

            *valueAddress = (k + 1)*(j + 1); //populate the Vector with int values
        }

        vectorPointer++; //Switch to next Vector.ILLEGAL arithmetic

    }

Answer 1

Actually, you only need one pointer. One way of doing it is by allocating enough memory to hold all the values, and then have functions that map the x/y values in the array to the respective memory location. Assume we want those to be the dimensions and our array variable:

int dimX = 10, dimY = 5;
int *array;

You can set a value this way:

void arraySet(int value, int x, int y) {
    array[x + dimX * y] = value;
}

And get a value this way:

int arrayGet(int x, int y) {
    return array[x + dimX * y];
}

Allocate the memory beforehand such as in the main function:

array = malloc(sizeof(int)*dimX*dimY);

Use it like this:

arraySet(123, 9, 3); // sets the value of [9, 3] to 123
printf("Memory at 9, 3 is %d\n", arrayGet(9, 3));

Answer 2

This "two pointers" idea doesn't make any sense and the code you posted cannot be salvaged. What you should do instead is to use a pointer to a 2D array:

int (*ptr)[x][y] = malloc(sizeof *ptr);
...
free(ptr);

That's it. However, a pointer to a 2D array is cumbersome, since we have to de-reference it before accessing the actual array. That is, we'd end up writing (*ptr)[i][j] = ...; which is ugly.

To dodge this, we can instead still allocate a 2D array, but instead of pointing at "the whole array", we point at the first element, which is a 1D array:

int (*ptr)[y] = malloc( sizeof(int[x][y]) );
...
ptr[i][j] = ... ; // more convenient syntax for access
...
free(ptr);

More info: Correctly allocating multi-dimensional arrays

Answer 3

You can simulate int a[2][3]; with

• one dimensional array and index computing:

  int* matrix = (int*) malloc(6 * sizeof(int));
  
  int get_matrix_2_3(int* matrix, int i, int j) { return matrix[3 * i + j]; }
  

• 2-dimensional array:

  int** matrix = (int**) malloc(2 * sizeof(int*));
  for (int i = 0; i != 2; ++i) {
       matrix[i] = (int*) malloc(3 * sizeof(int));
  }
  
  matrix[1][2] = 42;