c++ - 从虚拟堆栈评估可变参数

Question

我正在制作一个基于字节码脚本的小型堆栈引擎，以了解 C++ 中的嵌入式脚本。目标是能够注册任何 std::function由脚本调用。我现在拥有的基本上是

class Bytecode
{
private:
Stack stack;

// Functions to be called from script.
// When a function is called, its arguments are expected to be in the stack.
std::vector<std::function<void(void)> > ops;

public:
// Register C++ function to be called by script
template<typename Func, typename T, typename... Args>
std::size_t function(Func fn, T arg, Args... args)
{
    // Substitute value from the stack to function parameter.
    auto fn2 = [fn,this](Args ...args) { fn(stack.pop().number, args...); };

    return function(fn2, args...);
}

template<typename Func, typename T>
std::size_t function(Func fn, T arg)
{
    std::function<void(void)> fn2 = [fn, this]() { fn(stack.pop().number); };

    return function(fn2);
}

template<typename Func>
std::size_t function(Func fn)
{
    ops.push_back(fn);

    // Return bytecode of the function (the same as ops index).
    return ops.size() - 1;
}
};

那我可以做

void myfunc(double a, double b)
{
    std::cout << a + b << std::endl;
}

int main()
{
Bytecode bytecode;

// The last two arguments are dummy
auto op = bytecode.function(myfunc, 3.4, 3.6);
}

所以这行得通，但我想避免给出伪参数。我试过重载 std::size_t function(std::function<void(T, Args...>) fn)但没有成功，因为它似乎专注于 std::function模板参数与普通模板参数的工作方式不同。有什么想法吗？

一个解决方案

我最终通过反复试验获得了某种可行的解决方案。抱歉，这个问题在所需用例方面有些含糊。

template<class T, class... Args>
std::size_t function(std::function<void(T,Args...)> &&fn)
{
    // Substitute value from the stack to function parameter.
    auto fn2 = [fn, this](Args ...args) { fn(stack.pop().as<T>(), std::forward<Args>(args)...); };

    return function(std::forward<std::function<void(Args...)> >(fn2));
}

std::size_t function(std::function<void(void)> &&fn)
{
    ops.push_back(fn);

    // Return bytecode of the function (the same as ops index).
    return ops.size() - 1;
}

以及一个具有不同类型参数的函数的用例

void myfunc(double foo, int bar)
{
    std::cout << foo + bar << std::endl;
}

int main()
{
    Bytecode bytecode;

    auto op = bytecode.function(std::function<void(double,int)>(myfunc));
}

所以函数指针必须包裹在std::function中但我认为没关系。

Answer 1

函数指针不是std::function。您不能(从 C++14 开始)从函数指针推断出 std::function 模板的类型。 C++17 正在引入这种特性。

一种方法是这样的:

template<typename Func, std::size_t...Is>
std::size_t function(Func fn, std::index_sequence<Is...>) {
  std::function<void()> fn2 = [fn, this]() {
    // array guarantees left-to-right evaluation:
    double elems[] = { ( void(Is), stack.pop().number)... } // comma operator and init list
    fn( elems[Is]... );
  };
  ops.push_back(fn2);
  return ops.size()-1;
}
template<std::size_t N, typename Func>
std::size_t function(Func fn) {
  return function(fn, std::make_index_sequence<N>{});
}

现在您只需在调用点指定参数计数:

auto op = bytecode.function<2>(myfunc);

现在，您可以从函数指针推断出类型，但在更一般的情况下您不能。在我看来，明确说明您期望的类型无论如何都是一个好主意。

此解决方案使用 C++14 索引序列和 make 索引序列。每个的简短 C++11 实现都可以在堆栈溢出中找到。

namespace notstd {
  template<std::size_T...Is>
  struct index_sequence {};

  template<std::size_t N, std::size_t...Is>
  struct make_index_sequence:
    make_index_sequence<N-1, N-1, Is...>
  {};
  template<std::size_t...Is>
  struct make_index_sequence<0, Is...>:
    index_sequence<Is...>
  {};
}

上面是一个相对低质量的实现，但对于上面的代码来说已经足够好了，在 C++11 中。