Array compile-time generated? - c++

Question

In this answer (it is not strictly necessary to read the whole question + answer) some code produces a compile-time array like:
template<unsigned...Is,class Tuple>
unsigned index_of(indexes<Is...>,void const* p, Tuple const&t){
void const* r[]={ nullptr, &std::get<Is>(t)... }; // <-- this is the array I'm referring to
auto it = std::find( std::begin(r), std::end(r), p );
if (it==std::end(r))
return -1;
else
return (it-std::begin(r))-1;
}
My question is: is that array entirely compile-time generated with the addresses of each element of a tuple? Is that the compile-time advantage? Or is the array runtime-generated (in that case, where's the compile-time advantage at all?)
Rephrased: why is the complex templated code here necessary at all instead of a simple runtime function which iterates with a for loop over all the elements of the tuple and compares the pointers? What's the gain in all that?? Something regarding the array creation? I don't really see it and I can't believe all that work was done for nothing or just to brag around "I can mess stuff up with templates, take a look"

Answer 1

No, since the tuple address is not known at compile-time. The only thing thats known at compile time is the size of the array, since its extracted from the size of the tuple (Via pack expansion).
Thats a weird algorithm thats only doing type erasure via void* to be able to store tuple elements on an array and then do something on them via standard algorithms.
This has much more sense (Indices trick ommitted to be more clear):
template<typename Tuple , typename T>
bool find_in_tuple( const Tuple& t , const T& e )
{
bool result[] = { (std::get<Indices>( t ) == e)... };
return std::any_of(std::begin(result) , std::end(result) , [](bool b){ return b; } );
}
Here is a running example.
For the index_of feature, you can add a counter to the closure when doing any_of(), or do something more complicated like this:
template<typename Tuple , typename T>
std::index_of index_of( const Tuple& t , const T& e )
{
std::size_t index = 0;
std::tuple<bool,std::size_t> result[] = { std::make_tuple(Indices,std::get<Indices>( t ) == e)... };
bool exists = std::any_of(std::begin(result) , std::end(result) , [&](const std::pair<std::size_t,bool>& p){ index = p.first; return p.second; } );
if(exists)
return index;
else
throw std::bad_argument{};
}