Initializing a constexpr array of function pointers

Question

I'd like to convert a runtime value int v into a call to a corresponding function with non-type template parameter v, e.g., template <int v> void hello().

Here's the brute force way of writing it:

using fn_type = void();

template <int v>
void hello() {
    // of course ITRW this function requires v to be a
    // constexpr value
    printf("hello: %d\n", v);
}

static std::array<fn_type *, 3> lut = {
    hello<0>,
    hello<1>,
    hello<2>
};

void hello_dispatch(int v) {
    lut[v](); // we don't handle OOB values b/c we are naughty like that
}

I can live with that for 3 values, but this gets impractical with more values, or when the the limit is itself calculated from some other compile-time value.

How can initialize the LUT² at compile-time without explicitly listing the various instantiations hello<0>, hello<1>, ... in the initializer?

This is what I came up with:

template <size_t I, size_t MAX>
constexpr void make_helper(std::array<fn_type *, MAX>& a) {
    if constexpr (I < MAX) {
        a[I] = hello<I>;
        make_helper<I + 1, MAX>(a);
    }
}

template <size_t MAX>
constexpr std::array<fn_type *, MAX> make_lut() {
    std::array<fn_type *, MAX> ret{};
    make_helper<0, MAX>(ret);
    return ret;
}


static constexpr std::array<fn_type *, 3> lut2 = make_lut<3>();

There has got to be something simpler, better and more idiomatic in C++17 - in particular, without needing recursion.

² Or, in case this an an XY problem, how can I implement hello_dispatch without a LUT (but with at least the efficiency of the LUT).

Well, for as simple function as hello, it might even be faster to pass the argument at runtime rather than use a lookup table. — eerorika
– eerorika, Commented Nov 7, 2019 at 0:24
@eerorika - definitely, if hello really just contained a printf, there would be no point. In reality, hello has an implementation which requires v to be a compile-time known value. — BeeOnRope
– BeeOnRope, Commented Nov 7, 2019 at 0:26

songyuanyao · Accepted Answer · 2019-11-07 02:21:21Z

4

You can initialize the std::array directly, i.e. don't need to assign the elements one by one with recursion.

template<std::size_t... I>
constexpr auto make_helper(std::index_sequence<I...>) {
    return std::array<fn_type *, sizeof...(I)> { hello<I>... };
}
template <std::size_t MAX>
constexpr auto make_lut() {
    return make_helper(std::make_index_sequence<MAX>{});
}

LIVE

edited Nov 7, 2019 at 2:21

answered Nov 7, 2019 at 1:12

songyuanyao

174k16 gold badges328 silver badges433 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Kirill Korolev · Accepted Answer · 2019-11-07 02:17:01Z

2

Use std::integer_sequence and fold expressions:

template <int... Is>
constexpr std::array<fn_type*, sizeof...(Is)> make_lut(std::integer_sequence<int, Is...>) {
    std::array<fn_type*, sizeof...(Is)> res{};
    ((res[Is] = &hello<Is>), ...);
    return res;
}

template <int Max>
constexpr auto make_lut() {
    return make_lut(std::make_integer_sequence<int, Max>{});
}

static constexpr auto lut2 = make_lut<3>();

std::make_integer_sequence<int, N>{} creates an object of type std::integer_sequence<int, 0, 1, 2, ..., N - 1>.
We capture these values with the first function template and assign each hello<N> to res[N] with the fold expression res[Is] = &hello<Is>.
We can apply a comma operator to the value on the left hand side of the ... fold.

edited Nov 7, 2019 at 2:17

Kirill Korolev

1,0163 gold badges10 silver badges23 bronze badges

answered Nov 7, 2019 at 0:34

Fatih BAKIR

4,9301 gold badge25 silver badges28 bronze badges

4 Comments

eerorika Over a year ago

std::make_index_sequence might be slightly simpler option here.

Fatih BAKIR Over a year ago

@eerorika, sure, I used ints since that's what OP used in the question.

Kirill Korolev Over a year ago

Did you test your solution? Because it doesn't compile

eerorika Over a year ago

The addition in the fold expression is unnecessary. Just use the comma operator as the binary operator: ((res[Is] = hello<Is>), ...)

max66 · Accepted Answer · 2019-11-07 20:25:37Z

And now, for something completely different...

If you can use C++20, you can use template-lambdas and you can completely avoid the lut array

#include <iostream>
#include <utility>

template <int v>
void hello()
 { std::cout << "hello: " << v << std::endl; }

void hello_dispatch (int v)
 {
   [&]<int ... Is>(std::integer_sequence<int, Is...> const &)
      { ((v == Is ? (hello<Is>(), 0) : 0), ...); }
         (std::make_integer_sequence<int, 100u>{}); // 100 is top limit (former lut size)
 }

int main ()
 {
   hello_dispatch(42);
 }

If you can use only C++17... not so elegant but you can use a recursive generic lambda

#include <iostream>
#include <utility>

template <int v>
void hello()
 { std::cout << "hello: " << v << std::endl; }

template <int I>
using IC = std::integral_constant<int, I>;

void hello_dispatch (int v)
 {
   auto lf = [&](auto self, auto ic)
    { if constexpr ( ic < 100 )
         v == ic ? (hello<ic>(), 0)
                 : (self(self, IC<ic+1>{}), 0); };

   lf(lf, IC<0>{});
 }

int main ()
 {
   hello_dispatch(42);
 }

Collectives™ on Stack Overflow

Initializing a constexpr array of function pointers

3 Answers 3

Comments

4 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

4 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related