Question

我正在尝试用C ++编程一个框架，用户可以在其框架内指示一组函数，在这个框架中他想要应用memoization策略。

所以我们假设我们的程序f1...f5中有5个函数，如果我们已经调用它们，我们希望避免对函数f1和f3进行（昂贵的）重新计算用相同的输入。 请注意，每个函数可以有不同的返回和参数类型。

我找到了问题的this解决方案，但您只能使用double和int。

我的解决方案

好的我为我的问题编写了这个解决方案，但我不知道它是否有效，类型安全或者可以用更优雅的方式编写。

template <typename ReturnType, typename... Args>
function<ReturnType(Args...)> memoize(function<ReturnType(Args...)> func)
{
    return ([=](Args... args) mutable {
        static map<tuple<Args...>, ReturnType> cache;
        tuple<Args...> t(args...);
        auto result = cache.insert(make_pair(t, ReturnType{}));
        if (result.second) {
            // insertion succeeded so the value wasn't cached already
            result.first->second = func(args...);
        }
        return result.first->second;
    });
}

struct MultiMemoizator
{
    map<string, boost::any> multiCache;
    template <typename ReturnType, typename... Args>
    void addFunction(string name, function < ReturnType(Args...)> func) {
        function < ReturnType(Args...)> cachedFunc = memoize(func);
        boost::any anyCachedFunc = cachedFunc;
        auto result = multiCache.insert(pair<string, boost::any>(name,anyCachedFunc));
        if (!result.second)
            cout << "ERROR: key " + name + " was already inserted" << endl;
    }
    template <typename ReturnType, typename... Args>
    ReturnType callFunction(string name, Args... args) {
        auto it = multiCache.find(name);
        if (it == multiCache.end())
            throw KeyNotFound(name);
        boost::any anyCachedFunc = it->second;
        function < ReturnType(Args...)> cachedFunc = boost::any_cast<function<ReturnType(Args...)>> (anyCachedFunc);
        return cachedFunc(args...);
    }
};

这可能是主要的：

int main()
{
    function<int(int)> intFun = [](int i) {return ++i; };
    function<string(string)> stringFun = [](string s) {
        return "Hello "+s;
    };
    MultiMemoizator mem;
    mem.addFunction("intFun",intFun);
    mem.addFunction("stringFun", stringFun);
    try
    {
        cout << mem.callFunction<int, int>("intFun", 1)<<endl;//print 2
        cout << mem.callFunction<string, string>("stringFun", " World!") << endl;//print Hello World!
        cout << mem.callFunction<string, string>("TrumpIsADickHead", " World!") << endl;//KeyNotFound thrown
    }
    catch (boost::bad_any_cast e)
    {
        cout << "Bad function calling: "<<e.what()<<endl;
        return 1;
    }
    catch (KeyNotFound e) 
    {
        cout << e.what()<<endl;
        return 1;
    }
}

Answer 1

这样的事情怎么样：

template <typename result_t, typename... args_t>
class Memoizer
{
public:
    typedef result_t (*function_t)(args_t...);
    Memoizer(function_t func) : m_func(func) {}

    result_t operator() (args_t... args)
    {
        auto args_tuple = make_tuple(args...);

        auto it = m_results.find(args_tuple);
        if (it != m_results.end())
            return it->second;

        result_t result = m_func(args...);
        m_results.insert(make_pair(args_tuple, result));
        return result;
    }

protected:
    function_t m_func;
    map<tuple<args_t...>, result_t> m_results;
};

用法是这样的：

// could create make_memoizer like make_tuple to eliminate the template arguments
Memoizer<double, double> memo(fabs);
cout << memo(-123.456);
cout << memo(-123.456); // not recomputed

Answer 2

很难猜测你是如何计划使用这些功能的，无论有没有记忆，但对于各种容器 - function<>方面你只需要一个共同基类：

#include <iostream>
#include <vector>
#include <functional>

struct Any_Function
{
    virtual ~Any_Function() {}
};

template <typename Ret, typename... Args>
struct Function : Any_Function, std::function<Ret(Args...)>
{
    template <typename T>
    Function(T& f)
      : std::function<Ret(Args...)>(f)
    { }
};

int main()
{
    std::vector<Any_Function*> fun_vect;
    auto* p = new Function<int, double, double, int> { [](double i, double j, int z) {
        return int(i + j + z);
    } };
    fun_vect.push_back(p);
}

Answer 3

这个问题是如何使它类型安全。看看这段代码：

MultiMemoizator mm;
std::string name = "identity";
mm.addFunction(name, identity);
auto result = mm.callFunction(name, 1);

最后一行是否正确？ callFunction具有正确类型的参数数量是否合适？什么是返回类型？

编译器无法知道：它无法理解name是"identity"，即使它确实存在，也无法将其与函数类型相关联。这不是特定于C ++的，任何静态类型的语言都会遇到同样的问题。

一个解决方案（基本上是Tony D的答案中给出的解决方案）是在调用函数时告诉编译器函数签名。如果你说错了，就会发生运行时错误。这可能看起来像这样（你只需要明确指定返回类型，因为推断出参数的数量和类型）：

auto result = mm.callFunction<int>(name, 1);

但这不够优雅且容易出错。

根据您的具体要求，更好的方法是使用＆＃34; smart＆＃34;键，而不是字符串：键的类型中嵌入了函数签名，因此您不必担心正确指定它。这可能看起来像：

Key<int(int)> identityKey;
mm.addFunction(identityKey, identity);
auto result = mm.callFunction(identityKey, 1);

这样，在编译时检查类型（addFunction和callFunction），这应该可以为您提供所需的内容。

我还没有在C ++中实现这一点，但我没有看到任何理由为什么它应该是难的或不可能的。尤其是doing something very similar in C# is simple。

Answer 4

乍一看，如何定义一个具有不同功能的模板参数的类型，即：

template <class RetType, class ArgType> 
class AbstractFunction {
    //etc.
}

让AbstractFunction获取函数指针f1-f5，每个函数的模板特化不同。然后，您可以使用通用的run_memoized（）函数，作为AbstractFunction的成员函数，或者将AbstractFunction作为参数的模板化函数，并在运行它时维护备忘录。

最难的部分是如果函数f1-f5有多个参数，在这种情况下你需要用arglists作为模板参数做一些时髦的事情，但我认为C ++ 14有一些可能会有的功能这可能。另一种方法是重写f1-f5，以便它们都将单个结构作为参数而不是多个参数。

编辑：看过你的问题1，你遇到的问题是你想拥有一个数据结构，其值是memoized函数，每个函数都有不同的参数。

我个人会通过使数据结构使用void *来表示单个memoized函数来解决这个问题，然后在callFunction（）方法中使用从void *到您需要的模板化MemoizedFunction类型的不安全类型转换（您可能需要使用“new”运算符分配MemoizedFunctions，以便可以将它们转换为void * s。）

如果缺少类型安全在这里让你感到烦恼，对你有好处，在这种情况下，为每个f1-f5制作手写的辅助方法并让callFunction（）调度其中一个函数可能是一个合理的选择。基于输入字符串。这将允许您使用编译时类型检查。

编辑＃2：如果要使用此方法，则需要稍微更改callFunction（）的API，以便callFunction具有与函数的返回和参数类型匹配的模板参数，例如：

int result = callFunction<int, arglist(double, float)>("double_and_float_to_int", 3.5, 4);

并且如果此API的用户在使用callFunction时输入参数类型或返回类型错误...为他们的灵魂祈祷，因为事情会以非常丑陋的方式爆炸。

编辑＃3：您可以在某种程度上使用std :: type_info在运行时进行类型检查，并在MemoizedFunction中存储参数类型和返回类型的typeid（），以便您可以检查模板参数在调用之前callFunction（）是正确的 - 所以你可以防止上面的爆炸。但是每次调用函数时，这都会增加一些开销（你可以将它包装在IF_DEBUG_MODE宏中，只在测试期间增加这种开销而不是在生产中。）

Answer 5

您可以使用带有void someFunction(void *r, ...)签名的函数向量，其中r是结果的指针，...是可变参数列表。警告：解压缩参数列表真的很不方便，看起来更像是黑客。

用于不同签名功能的容器

5 个答案: