constexpr 可构造函数对象

Question

我有一个与this one 有点相似的问题，但对于一个更有限的情况，我认为这应该是可能的：我想从多个 lambda 构造一个静态 constexpr 函数调用数组，每个 lambda 共享相同的签名.静态和 constexpr 部分在这里很重要，因为我在嵌入式系统上，我想确保这些表最终出现在 Flash 中。

所以基本上我想做的是

#include<vector>
#include<functional>
#include<variant>

using params_t = std::vector<std::variant<int, float /*maybe others*/ >>;

struct command_t {
   using callable_t = std::function<void(params_t)>;

  const callable_t func;
   //other members..
};

class AClass {
    template<typename func_t>
    constexpr static command_t::callable_t make_callable(func_t fun) {
         return [fun](params_t params){/*construct a call to fun using params and template magic*/};
    }

    static void mycommand();
    static void mycommand2(int i);

    //The following fails: 
    ///"error: in-class initialization of static data member 'const command_t AClass::commands [2]' of non-literal type"
    static constexpr command_t commands[2] = {command_t{make_callable(mycommand)},
                                              command_t{make_callable(mycommand2)}};
};

On coliru

请注意，这里的类型擦除非常有限，因为 lambda 的签名仅因捕获 fun 的签名而异。函数调用显然不需要（也不能）是 constexpr，只需构造。

所以基本上我的问题是我能否以某种方式制作commands 数组static constexpr，或者以某种方式使用std::function, 或inplace_function 之类的东西，或者可能通过旋转我自己的代码来对特定类型的lambda 进行类型擦除案例？

Answer 1

一般来说，这是不可能的，因为 lambda 的捕获可能会变得任意大，因此，在某些时候我们需要一个堆分配，这会扼杀 constexpr pre-C++20 的任何希望（我不认为 C++20 对这种情况也有很大帮助）。

但如果我认为这是正确的并且我们可以这样做，您只想捕获一个函数指针：

#include <vector>
 #include<variant>

using params_t = std::vector<std::variant<int, float /*maybe others*/ >>;

struct command_t {
   using callable_t = void (*)(std::vector<params_t>); 

  const callable_t func;
   //other members..
};

 template<auto f> 
 void wrap(std::vector<params_t>){
    // make this dependent of f, maybe use function_traits for fancy stuff
 }
class AClass {

    static void mycommand();
    static void mycommand2(int i);

    static constexpr command_t commands[2] = {wrap<mycommand>, wrap<mycommand2>};
};

 int main() {

 }

感谢 xskxzr 的宝贵建议。

Answer 2

由于mycommanN 具有不同的签名并且您需要捕获它们，因此我看不到拥有 constexpr 向量的方法。也许有人能想出更好的设计。

我有一个解决方案：使用std::tuple。但我不太喜欢，因为将tuple 用作容器确实很麻烦。例如迭代它是......假设不是在公园里散步。无论如何，这是以防万一：

using params_t = std::vector<std::variant<int, float /*maybe others*/>>;

// I needed to lift this out of AClass because of ... complicated reasons
// (short version: when both are AClass members
//    the return type of `make_command` is not resolved in the init of `commands`
//    because both are static, `commands` is not a template and `make_command` is a template
//    tbh I don't know exactly what is happening. It's one of those dark corners of C++)

template <class RealFunc>
static constexpr auto make_command(RealFunc real_func) {
  return [real_func](params_t params) { /*magic*/ };
}

struct AClass {
  static void mycommand();
  static void mycommand2(int i);

  static constexpr std::tuple commands{make_command(mycommand),
                                       make_command(mycommand2)};
};

// usage
auto test() {
  constexpr auto command0 = std::get<0>(AClass::commands<>);

  params_t params0 = {};

  return command0(command0);
}