How does recursion work while defining multidimensional template arrays? - c++

Question

This is the code I found online.
template<class T, unsigned ... RestD> struct array;
template<class T, unsigned PrimaryD >
struct array<T, PrimaryD>
{
typedef T type[PrimaryD];
type data;
T& operator[](unsigned i) { return data[i]; }
};
template<class T, unsigned PrimaryD, unsigned ... RestD >
struct array<T, PrimaryD, RestD...>
{
typedef typename array<T, RestD...>::type OneDimensionDownArrayT;
typedef OneDimensionDownArrayT type[PrimaryD];
type data;
OneDimensionDownArrayT& operator[](unsigned i) { return data[i]; }
};
int main()
{
array<int, 2, 3>::type a4 = { { 1, 2, 3}, { 1, 2, 3} };
array<int, 2, 3> a5{ { { 1, 2, 3}, { 4, 5, 6} } };
std::cout << a5[1][2] << std::endl;
array<int, 3> a6{ {1, 2, 3} };
std::cout << a6[1] << std::endl;
array<int, 1, 2, 3> a7{ { { { 1, 2, 3}, { 4, 5, 6 } } }};
std::cout << a7[0][1][2] << std::endl;
}
Could you explain what this code does exactly? I understand that recursion is used in some form here to create a multidimensional array, but I am a little confused on how this process works.
I am also confused about this line:
array<int, 2, 3>::type a4 = { { 1, 2, 3}, { 1, 2, 3} };
What is the ::type?

Answer 1

This is whats called template specialization.
The first thing you must know is that anything defined with template is evaluated at compile time.
Looking at your code, there are two main cases we want to consider:
When the array is of one-dimension
When the array has more than one dimension
The following describes the one-dimensional case:
template<class T, unsigned PrimaryD >
struct array<T, PrimaryD>
{
typedef T type[PrimaryD];
type data;
T& operator[](unsigned i) { return data[i]; }
};
As you can see the above struct is specialized to only accept two template parameters, the first one is T the data type of the array, and the second is PrimaryD which simply means how long should the array be.
Now for the 2nd specialization:
template<class T, unsigned PrimaryD, unsigned ... RestD >
struct array<T, PrimaryD, RestD...>
{
// if the template contains array<int, 1, 2, 3, 4>
// then RestD... will unpack the values 2, 3, 4
typedef typename array<T, RestD...>::type
OneDimensionDownArrayT;
typedef OneDimensionDownArrayT type[PrimaryD];
type data;
// This will return an array type
// you can keep on making a call to operator[] until the type of the OneDimensionDownArrayT refers to the previous specialization
OneDimensionDownArrayT& operator[](unsigned i) { return
data[i];
}
};
Now for your example:
array<int, 2, 3>::type a4 = { { 1, 2, 3}, { 1, 2, 3} }
What the compiler will do is sort of match the template parameters namely, int, 2, and 3 which evaluate to the 2nd specialization.
Let's follow it through:
array<int, 2, 3> which is a struct contains the following concrete types:
OneDimensionalT which is equal to array<int, 3>
and an operator[] function that returns an array<int, 3>.
OneDimensionalT is equal to array<int, 3> because if you unpack the RestD... values you will only get 3, the 2 is already consumed by the first template parameter, PrimaryD.
Adding a 3rd dimension follows the same logic, keep on defining smaller dimension struct array types recursively using only the n-1 dimension values of the parameter pack RestD...
Oh and btw, the line on the top is just to declare the base type so we can specialize it.