C++: getting the row size of a multidimensional array passed to a function

Question

I'm trying to write a function that will print out the contents of a multidimensional array. I know the size of the columns, but not the size of the rows.

EDIT: Since I didn't make this clear, the arrays passed to this function are NOT dynamically allocated. The sizes are known at compile time.

I am testing it using a 3x2 array. Here is the function as it stands:

void printArrays(int array1[][2], int array2[][2]) {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 2; j++) {
            cout << "\narray1[" << i << "][" << j << "] = "
                 << setfill('0') << setw(2) << array1[i][j]
                 << "\tarray2[" << i << "][" << j << "] = "
                 << setfill('0') << setw(2) << array2[i][j];
        }
    }
}

Obviously, this only works if I know the size of "i" is 3 (it is in this case). Ideally, however, I would like the function to work no matter what the size of the first dimension.

I thought I would be able to do this using the sizeof() function, e.g.

int size = sizeof(array1);

... and do some math from there.

Here's the odd part. If I use the sizeof() function inside the array, it returns a value of 4. I can use pointer notation to dereference the array:

int size = sizeof(*array1);

... but this actually returns a value of 8. This is odd, because the total size should be rows(which = 3) * columns(= 2) * sizeof(int)(= 4), or 24. And, indeed, this is the result, when I use sizeof(*array1) outside of the function.

Does anyone know what is going on here? More importantly, does anyone have a solution?

Answer 1

The answer is that you can not do this. You must pass the number of rows as an argument to the function, or use an STL container such as std::vector or std::array.

sizeof is computed compile time; sizeof is never useful in determining dynamic size of objects in C/C++. You (yourself, the programmer) can always calculate sizeof(x) just from looking at code and header files since sizeof counts the number of bytes used to represent the object. sizeof(*array1) will always be 8 since array1[i] is an array of two ints and 4==sizeof(int). When you declare int array1[][2] this is equivalent to int *array1[2]. That is, array1 is a pointer to arrays of two integers. sizeof(array1) is therefore 4 bytes, since it takes 4 bytes on your machine to represent a pointer.