How to pass 3D arrays using triple pointers? - c++

Question

Is it really possible?
I know how to pass 2-D arrays using double pointer. And as per my understanding, it should for 3-D arrays as well. But I would love to be proven wrong. This question will surely reveal how the arrays are interpreted.
The fact here is that the 3-D array is a contiguous block, not some array of pointers of smaller chunks.
This program gives me error :
#include <iostream>
using namespace std;
void display(int ***arr, int l, int m, int n)
{
for(int i=0; i<l; i++)
for(int j=0; j<m; j++)
for(int k=0; k<n; k++)
cout << *(*(*(arr+i)+j)+k) << endl;
}
int main()
{
int arr[][2][2] = {{{1,2},{3,4}},{{10,20},{30,40}}};
display((int***)arr,2,2,2);
}
OUTPUT
test.cpp:17:19: error: cannot convert 'int (*)[2][2]' to 'int***' for argument '1' to 'void display(int***, int, int, int)'
display(arr,2,2,2);
^
2D Arrays passed to double pointer
I believe I can do something similar to 3D arrays as well, but this is way too bad to read.
#include <iostream>
using namespace std;
void display(int **arr, int m, int n)
{
for(int i=0; i<m; i++)
for(int j=0; j<n; j++)
cout << *(*(arr+i)+j) << " " << arr[i][j] << endl;
}
int main()
{
int arr[][3] = {{1,2,3},{4,5,6}};
int *temp[2];
for(int i=0; i<2; i++)
temp[i] = *(arr+i);
display(temp,2,3);
}
OUTPUT
1 1
2 2
3 3
4 4
5 5
6 6

Answer 1

What you do for 2D arrays is correct because you have built an auxiliary array of pointers and you pass that array of pointer as a int **. Even for 2D arrays, this
void display(int **arr, int m, int n);
...
int arr[][3] = {{1,2,3},{4,5,6}};
display(arr,2,3); // WRONG! use a 2D array as an array of pointers
would be wrong.
And anyway, the C++ standard is unfriendly with multi-dimensional arrays: there is no way to write a strictly conformant program passing a multi-dimensional arrays of unknown dimension. Many compilers accept it as extensions, but it may be non portable on other compilers.
The idiomatic way is to only use 1D arrays as the underlying data structure, and provide methods to process it as a multi-dimensional container by internally doing index computations.
BTW I have tried to build a multi-dimensional contiguous container with arbitrary run-time dimensions, respecting all the constraints of the standard containers, and given up after realizing that the standard did not allow it: it is impossible to build a nice iterator over object that do not hold their own data. Here is my best attempt. The answers and comments explain why it is hopeless.

Answer 2

Although you can pass a 1-D array like this
void pass1Darray(int a[])
{
statements;
}
int main()
{
int a[10];
pass1Darray(a);
}
In fact, compiler would see int a[] as int* a and this is the reason why people wonder is it possible to pass a 2-D array by pointer_to_pointer.
But it doesn't make sense!
If you want to pass a 2-D arraybob[5][10], you can see bob as a array and its element is a array, and pass it like this
void pass2Darray( int (*array) [10] ) // it means you pass a pointer which points to a int[10]
{
statements;
}
int main()
{
int bob[5][10];
pass2Darray(bob);
}
This is about passing a 2-D array.
btw, English is not my native langueue, and I'm a beginner of c++ , too.
If there's something wrong, please let me know, thank you.

Answer 3

When you declare an array locally int arr[][2][2] the compiler instantiate a one dimensional vector and "remember" what the offset is to get the right index.
Also local arrays are stored in the stack which is not good if you need large matrices. Another property of int arr[][2][2] is that why when you try to pass it as argument to a function, int arr[][2][2] is the type. You have to specify all the dimensions.
Pointers work differently. If you instantiate a 2D array you need to allocate an array of pointers to rows, and allocate each row array to hold data individually. In C++ I think it's best to use the standard library, which has a standard implementation of dynamic pointers that take care of all allocations. std::vector
In conclusion:
I would use local arrays when the memory required is small and I don't need to use pointers. Local arrays are good if you want to avoid using the heap.
Using pointersm new/delete or malloc/free is allowed but I think it's better to use the standard library in C++, so I would use std::vector in all other scenarios.

Answer 4

I believe I can do something similar to 3D arrays as well, but this is way too bad to read.
Yes, as n.m. explained in their comment
In your 2D code you have created a brand new array of pointers, populated it, and passed it to your function instead of your original 2D array. In your 3D code you have not attempted anything of the sort.
Since the question is tagged as C++, we can use a different toolbox than C coders have to.
In C++, a parameter can be passed to a function by reference, not only by value, and we can write a template that can be used by the compiler to generate the right function for used type.
#include <iostream>
#include <iomanip>
template <class T, size_t L, size_t M, size_t N>
void display( T const (&arr)[L][M][N], int width )
// ^^^^^^
{
for (size_t i = 0; i < L; ++i) {
for (size_t j = 0; j < M; ++j) {
for (size_t k = 0; k < N; ++k) {
std::cout << std::setw(width) << arr[i][j][k];
}
std::cout << '\n';
}
std::cout << '\n';
}
}
int main()
{
int arr[3][2][4] = {
{ {1,2,3,4},
{5,6,7,8}
},
{ {10,20,30,40},
{50,60,70,80}
},
{ {100,200,300,400},
{500,600,700,800}
}
};
display(arr, 5);
}
Live, HERE.
The next step would be, of course, to write a class which encapsulates the concept of a multidimensional array.