可以包装可调用对象的文字类型，例如 function 或成员 function

Question

I would like to call a function F with some fixed signature which itself wraps a call to a member function Foo::*p of some class Foo . The member functions come in too flavours:

• int* m1() {...} , and,
• template <typename T> void m2(T t) {...}

and there are two versions of F (the second one being a template, of course) depending of what member function flavour there is.

The number of member function of Foo and possible calls for F is finite and known at compile time. I was trying to do something along the following lines:

struct Foo {
    void m1(int) {}
    int* m2() { return &x; }
    int x = 0;
};

using FunT = std::function<bool(int)>;

FunT Make1(void(Foo::*pf)(int)) {
    return [pf](int){return true;};
}
FunT Make2(int*(Foo::*pf)()) {
    return [pf](int){return true;};
}

static std::array a = {
  Make1(&Foo::m1),
  Make2(&Foo::m2)
};

template <int i> FunT FunToCall() {
    return a[i];
}

template <int... is> bool make_calls(Foo& foo, int arg) {
    return (FunToCall<is>()(is)&& ...);
}

int main() {
    Foo foo;
    make_calls<0,1>(foo, 5);
}

which compiles and runs.

Now, if main called make_calls<0,1,2>(foo, 5); the program will throw at run time—to prevent this I want to move the check to compile time by making both the array a and the getter FunToCall constexpr . Starting with array, however I hit a roadblock:

<source>:37:29: error: the type 'const std::array<std::function<bool(int)>, 2>' of 'constexpr' variable 'a' is not literal
   37 | static constexpr std::array a = {
      |                             ^
In file included from <source>:1:
/opt/compiler-explorer/gcc-11.2.0/include/c++/11.2.0/array:95:12: note: 'std::array<std::function<bool(int)>, 2>' is not literal because:
   95 |     struct array
      |            ^~~~~
/opt/compiler-explorer/gcc-11.2.0/include/c++/11.2.0/array:95:12: note:   'std::array<std::function<bool(int)>, 2>' has a non-trivial destructor

I understand the error and I've tried each and every way to come up with something that works but couldn't figure out a way.

Is there a known idiom/pattern here that can be used here? More generally, any ideas how to make this work (so the out-of-bounds check happens at compile time)?

As suggested by @Igor Tandetnik, a possible work-around is to use static_assert inside of FunToCall (since the std::array size is a compile-time constant). Would still like to know if the array can somehow be made constexpr .

Answer 1

template <int i> FunT FunToCall() {
    static_assert(i < std::tuple_size_v<decltype(a)>);
    return a[i];
}

Demo . The size of std::array is a compile-time constant even if the array itself is not constexpr . It's part of the type.