get total number of elements in a multidimensional array using std::extent - c++

Question

How to find total number of elements in a multidimensional array using std::extent. This is my sample code:
#include <iostream>
#include <type_traits>
int main()
{
int32_t int_arr[10][100][1000];
int32_t no_of_elements = 1;
// compiler error in below for loop block
for (int32_t i = 0; i < std::rank<decltype(int_arr)>{}; ++i)
no_of_elements *= std::extent<decltype(int_arr), i>{};
no_of_elements *= std::extent<decltype(int_arr), 0>{};
no_of_elements *= std::extent<decltype(int_arr), 1>{};
no_of_elements *= std::extent<decltype(int_arr), 2>{};
std::cout << no_of_elements << std::endl;
std::cout << sizeof(int_arr) / sizeof(std::remove_all_extents<decltype(int_arr)>::type) << std::endl;
return 0;
}
error: the value of ‘i’ is not usable in a constant expression 9 | no_of_elements *= std::extent<decltype(int_arr), i>{};

Answer 1

With C++14 std::index_sequence, you can use std::extent with something like:
template <typename T, std::size_t... Is>
constexpr std::size_t count_elements(std::index_sequence<Is...>)
{
return (1 * ... * std::extent<T, Is>{}); // C++17 fold expression
// Alternatives exist for C++11/C++14
}
template <typename T>
constexpr std::size_t count_elements()
{
return count_elements<T>(std::make_index_sequence<std::rank<T>{}>());
}
int main()
{
int32_t int_arr[10][100][1000];
int32_t no_of_elements = count_element<decltype(int_arr)>();
std::cout << no_of_elements << std::endl;
}

Answer 2

Much simpler way is to get the type of array element and then sizeof(array)/sizeof(element) is an answer:
int32_t int_arr[10][100][1000];
using element = std::remove_all_extents<decltype(int_arr)>::type;
no_of_elements = sizeof(int_arr)/sizeof(element);
So use remove_all_extents
in templated version (like in C++14 variable template):
template <typename ArrayType>
constexpr std::size_t no_of_elements_v =
sizeof(ArrayType) / sizeof(remove_all_extents_t<ArrayType>;
If you really insist on using C++11 and std::extent - this is the solution:
template <typename T, std::size_t rank = std::rank<T>{}, std::size_t dim = 0>
struct NumOfElements :
std::integral_constant<std::size_t, std::extent<T, dim>{} * NumOfElements<T, rank, dim + 1>::value>
{};
template <typename T, std::size_t rank>
struct NumOfElements<T, rank, rank> :
std::integral_constant<std::size_t, 1u>
{};
And use NumOfElements<decltype(int_arr)>::value
But much, much simpler is this simple template version w/o any type_traits, if you replace integral_constant with simple static member variable - it should work even in pre-C++11:
template <typename T>
struct NumOfElements : std::integral_constant<std::size_t, 1u>
{};
template <typename T, std::size_t N>
struct NumOfElements<T[N]> : std::integral_constant<std::size_t,
N * NumOfElements<T>::value>
{};

Answer 3

#include <iostream>
#include <type_traits>
#include <typeinfo>
template<class A>
size_t getSize(const A&)
{
typedef typename std::remove_all_extents<A>::type Type;
return sizeof(A) / sizeof(Type);
}
int main()
{
int a1[3][10];
float a2[5][10][10];
double a3[3][10];
std::int32_t int_arr[10][100][1000];
std::cout << "Size of array a1: " << getSize(a1) << std::endl;
std::cout << "Size of array a2: " << getSize(a2) << std::endl;
std::cout << "Size of array a3: " << getSize(a3) << std::endl;
std::cout << "Size of array int_arr: " << getSize(int_arr) << std::endl;
}
Output:
Size of array a1: 30
Size of array a2: 500
Size of array a3: 30
Size of array int_arr: 1000000
One minus of this code is function getSize() is generated for each type of array:
type of a1: int[3][10] (GCC outputs: A3_A10_i)
type of a2: float[5][10][10] (GCC outputs: A5_A10_A10_f)
type of a3: double[3][10] (GCC outputs: A3_A10_d)

Answer 4

I don't think std::extent is the right choice here. I'd simply define a "recursive" template:
template<typename T>
struct nested_array_size
{
static constexpr size_t value = 1;
};
template<typename T, size_t N>
struct nested_array_size<T[N]>
{
static constexpr size_t value = N * nested_array_size<T>::value;
};
std::cout << nested_array_size<double[1][2][3][4]>::value << std::endl;
std::cout << nested_array_size<int[5]>::value << std::endl;
std::cout << nested_array_size<int[5][6]>::value << std::endl;