Karl Giesing - 1 year ago 81
C++ Question

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

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?

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.