Casting int** to the "pointer to a two-dimensional array of integers with fixed number of elements per column"

Question

Lets assume there's variable of type int** which is the pointer to a 5x5 2D array:

int** ptr_array_5by5;

and a function with the following prototype:

void print2DArray_with5Columns(int (*ptr_row)[5]);

Is there a way to cast ptr_array_5by5 into some type which would match the type of the first argument of the function?

print2DArray_with5Columns( (<some casting type>) ptr_array_5by5)

Answer 1

Of course.

int** ptr_array_5by5;  
void print2DArray_with5Columns(int (*ptr_row)[5]);

print2DArray_with5Columns( (int (*)[5]) ptr_array_5by5);
print2DArray_with5Columns( reinterpret_cast<int (*)[5]>(ptr_array_5by5));

The C language declaration syntax, for all its faults, lets you create casts by simply rewriting the declaration omitting any identifiers. It compiles, and it might even work.

---

There is a lot of confusion here because the descriptive wording does not match the C declarations. Here is some code that implements this (peculiar) cast and shows that it can work, just as I said.

void print2DArray_with5Columns(int (*ptr_row)[5]) {
    for (int i = 0; i < 5; i++)
        cout << (*ptr_row)[i] << " ";
    cout << std::endl;
}

int main() {
    int* a;
    int** ptr_array_5by5;
    a = new int[25];
    for (int i = 0; i < 25; i++)
        a[i] = i;
    ptr_array_5by5 = (int**)a;
    print2DArray_with5Columns((int (*)[5])(ptr_array_5by5));
    return 0;
}

Please note that this declaration is not a 5x5 matrix. The cast is simply a pointer to an array of 5 ints, which decays to a simple array. This code generates a 5x5 flat matrix and prints the first row.

I suspect the real problem is that the cast is wrong and therefore the whole question is wrong.

---

The question has been asked whether this is the dreaded Undefined Behaviour. With suitable care it is not. The standard in effect allows any kind of a pointer-to-object to be cast to some other pointer-to-object or to a void pointer or to a large enough integer, and back again. [Pointer-to-function and pointer-to-member are treated a bit differently.] The round-tripped pointer is guaranteed to retain the same value. Therefore this cast is not UB provided the rules are followed, which is not that hard to do.

Answer 2

The important thing to realize here is that int** is not a pointer to a 2D array of anything. It is a pointer to a 1D array of pointers. int (*)[5] is a pointer to a 2D array of int (or more correctly, it is a pointer to the first element of such an array). You can pretty much convert any pointer type to any other pointer type using reinterpret_cast, but it is also pretty much guaranteed not to work at runtime. (There are special exceptions, but they are all very platform specific, and very close to the hardware.)

If you really have an int** which points to 5 int*, each of which points to 5 int, and you need an int (*)[5], the only way you're going to be able to successfully convert is by doing a conversion on the actual underlying data (which will involve a copy), and not a conversion on the pointer. Something like:

int tmp[5][5];
for ( int i = 0; i != 5; ++ i ) {
    int* row = ptr_array_5by5[i];
    for ( int j = 0; j != 5; ++ j ) {
        tmp[i][j] = row[j];
    }
}

You can then pass tmp to your function without any casts: the implicit conversion of array to pointer will convert int [5][5] to int (*)[5].

Answer 3

1. int** and int(*)[5] are different types (as n.m. pointed out)
2. You may treat an array as a pointer, e.g. int a[5]; *(a+1) = 6;
3. You may treat a pointer as an array, e.g. int *a = new int[5]; a[1] = 6;.

But treating object A as if it were an object B does not mean that it actually is object B.

What you can do though is declaring an int (*)[5], write the values of ptr_array_5by5 into it (after allocating memory, of course), and pass it to print2DArray_with5Columns.

On the other hand, yes there are casts that make your code compile. But I doubt that using one of them is getting you closer to your goal (see http://ideone.com/lVzNrN).

Answer 4

I think you are confused by assuming that pointers are arrays. Pointers are not arrays and vice-versa. If ptr_array_5by5 would be a 2D array then the parameter in prototype is fine for passing ptr_array_5by5 as argument. But you declared it as int **ptr_array_5by5, it is better to change the parameter to int ** type.

Answer 5

Why would you like to cast int **?

You use pointers to point to addresses.

So instead of type casting pointers, you have to point this pointer to some variable.

There is no meaning of type casting pointers because they themselves don't store values.