支持递归函数的自动记忆

Question

博文Automatic Memoization in c++0x 提供了一个函数，用于生成现有函数的记忆版本。该博客文章和相关代码之前已在 stackoverflow 上讨论过（例如What does this C++11 code do?），但是，这些解决方案都无法提供一个完全通用的记忆器，它也能够正确记忆递归函数。

当然，通过使用类似这样的东西来改变递归调用是有技巧的（假设我们已经有一个记忆器，比如博客文章中提到的那个叫做 memoize 的记忆器）：

std::function<int (int)> f;
int fib(int n) {
  if  (n < 2) return n;
  return f(n-1) + f(n-2);
}

int main(void) {
  f = memoize(std::function<int (int)>(fib));
}

但这感觉更像是一种解决方法，而不是一个适当的解决方案，因为我们仍然需要访问我们想要记忆的功能。一个适当的解决方案应该能够完全记忆任何功能，包括在某些库中定义的功能。但是，产生这样的解决方案似乎超出了我的能力范围（假设它是可能的），因此我问：

一个真正通用的记忆功能可能吗？
如何实现这样的壮举？

如果这是不可能的，是否至少有一种方法可以概括上述方法。类似于（无法编译且不是有效的 C++）：

int fib(int n){
  if  (n < 2) return n;
  return this_func(n-1) + this_func(n-2);
}

其中this_func 类似于类的this 指针，但用于函数。 [编辑：这可能仍然会受到this_func指针指向fib而不是记忆的fib的问题]

Answer 1

由于缓存需要在函数调用之间共享，您要么必须将其作为参数传递，要么以其他方式共享。共享它的一种方法是使用函数对象：

struct fib
{
    std::map<std::tuple<int>, int> cache;

    int operator()(int n)
    {
        if(n < 2) return n;

        auto memoize = [this](int p)
        {
            auto i = cache.find(p);
            if(i == cache.end()) i = cache.insert({p, (*this)(p)}).first;
            return i->second;
        };

        return memoize(n-1) + memoize(n-2);
    }
};

您可以在哪里分解memoize 部分。

还有一个临时生命周期的技巧，可以将记忆化的函数作为参数传递；像这样：

struct recurse // possibly a class template
{
    std::function<int(int, recurse const&)> f; // possibly `mutable`

    template<class T>
    recurse(T&& p) : f( memoize(decltype(f){p}) )
    {}

    int operator()(int x) const
    {
        return f(x, *this);
    }
};

int fib(int n, recurse const& f);

int fib(int n, recurse const& f = {fib})
{
    if(n < 2) return n;
    return f(n-1) + f(n-2); // or `fib(n-1, f) + fib(n-2, f)`
}

然而，这需要更改 memoize，因为 recurse const& 不能（也不应该）成为内部 map 的一部分。

_{注意那些const& 也可以是&& 以延长生命周期，但是，由于移动语义，这可能会令人困惑}

Answer 2

以下可能会有所帮助，但它仍然是一个 hack，而且很丑...：

int fib(void* f, int n)
{
  if (n < 2) return n;
  auto this_func = *reinterpret_cast<std::function<int (void*, int)>*>(f);
  return this_func(f, n - 1) + this_func(f, n - 2);
}


int main(int argc, char *argv[])
{
    std::function<int (void*, int n)> fib1 = &fib;
    std::cout << fib1(reinterpret_cast<void*>(&fib1), 5) << std::endl;

    auto f = memoize(fib1);
    std::cout << f(reinterpret_cast<void*>(&f), 5) << std::endl;

    return 0;
}

我使用void*，因为正确的签名是递归的：-/

Answer 3

我的猜测是，在定义的行为范围内这是不可能的，因为没有办法抽象出递归调用。事实上，我想不出比您提供的全局变量版本更好的东西了。

提供一个比全局变量更健壮的抽象点的一个明显想法是添加要递归的函数作为第一个参数：

int fib(std::function<int (int)> rec, int n)
{
    if (n < 2) return n;
    return rec(n - 1) + rec(n - 2);
}

然后，你可以修改你的 memoize 函数，将 memoized 版本传递给第一个参数，这样就可以正常工作了。这个技巧通常用于在（单类型/无类型）功能语言（如方案）中实现相同的目标。

但是，这种技巧依赖于称为 "Y combinator" 的东西，我认为它在 C++ 中不存在，因为它具有无限类型。