Question

这可能是错误的标题，但我不知道如何描述它。我要做的是从我的脚本语言（在VM中运行）调用C ++函数。我在弄清楚如何将参数传递给函数时遇到了一些麻烦。

到目前为止，我的最佳解决方案是：

void func(int a) {

// Start param copy
char c;
char* par_start = &c - sizeof(char) - getCurrentFuncParamOffset();
copyCurrentParams(par_start);
// End copy

// Code

}

然后，为了调用该函数，我首先将它暴露给VM，给它提供参数。这是一些缩短的代码，但是所有内容都被转换为void（*），因此它可以存储在哈希表中。

EXPOSE(test, int);
vm.call("test", 12)

EXPOSE获取指向函数测试的指针，并存储它需要调用一个函数。它将指针存储为哈希表中的void（*）（），这样当我想调用它时，我可以从VM进行调用并解析它。然后函数内部的代码（我从问题中的宏扩展）将把从调用VM传递的参数复制到函数的参数。

这可行，但它不是最优雅的解决方案，特别是因为我必须为每个我希望为脚本公开的函数调用一个宏。有更好的解决方案吗？谢谢。

Answer 1

您也可以使用C ++提供的功能。这是我把它放在一起的一个小例子。

class ScriptObj {}; // Your type that encapsulates script objects. 
                    // May be as simple as an integer or a string,
                    // or arbitrarily complex like PyObj

template <typename T> T from_script(ScriptObj); // conversion to and from
template <typename T> ScriptObj to_script(T);   // C++ types. You provide
                                                // specialized implementations.
                                                // Bad conversions should throw.

// Abstract base class for C++ functions callable from the scripts.
// The scripting engine should pass a vector of parameters and a pointer to result.
struct script2cxx
{
    virtual ~script2cxx() {}
    virtual ScriptObj operator()(const std::vector<ScriptObj>& params) = 0;
};    


// Concrete class that exposes a C++ function to the script engine.
template <class Res, class ... Param>
struct script2cxx_impl : script2cxx
{

    using funcType = Res(*)(Param...);

    virtual ScriptObj operator()(const std::vector<ScriptObj>& params)
    {
        if (sizeof...(Param) != params.size())
            throw std::domain_error("Invalid size of parameter array");
        return to_script<Res>(call_impl<std::tuple<Param...>>(func, params, std::make_index_sequence<sizeof...(Param)>()));
    }

    template <class Tuple, std::size_t... N>
        Res call_impl(funcType func, const std::vector<ScriptObj>& params, std::index_sequence<N...>)
        {
            return func(from_script<typename std::tuple_element<N, Tuple>::type>(params[N])...);
        };

    funcType func;

    script2cxx_impl(funcType func) : func(func) {}
};

// a helper biold function
template  <class Res, class ... Param>
auto expose(Res(*func)(Param...)) {
    return new script2cxx_impl<Res, Param...>(func);
}

现在，您可以构建script2cxx（智能）指针的映射，并使用脚本对象的向量调用它们。

 std::map<std::string, std::unique_ptr<script2cxx>> exposed;


 int foo(double, char[], int**) {...}

 // below is the only line you need to add
 // if you want to expose any standalone C++ function.
 // no boilerplate.

 exposed["foo"]=expose(foo); // you can wrap this in a macro if you want

并打电话给他们：

 std::vector<ScriptObj> somevector = ...;
 std::string somestring = ...;
 (*exposed[somestring])(somevector);

在制作此示例时，没有任何不安全的演员和/或无效指针受到伤害。

动态C ++函数参数

1 个答案: