这个 C++11 代码 (memoize) 有什么作用？

Question

我找到了包含此代码的an article：

template <typename ReturnType, typename... Args>
std::function<ReturnType (Args...)>
memoize(std::function<ReturnType (Args...)> func)
{
    std::map<std::tuple<Args...>, ReturnType> cache;
    return ([=](Args... args) mutable {
            std::tuple<Args...> t(args...);
            if (cache.find(t) == cache.end())                
                cache[t] = func(args...);
            return cache[t];
    });
}

你能解释一下吗？这里很多东西我看不懂，但最奇怪的是缓存是本地的，不是静态的，但也许我错了……

Answer 1

这是memoization 的简单 C++1x 实现。

memoize 函数返回一个closure。返回值是一个函数，其状态与通过参数传递的状态不同（在本例中为cache 变量）。

匿名函数中的[=] 位表示返回的函数应该获取所有局部变量的副本。 cache 变量不是静态的，因为它旨在在返回函数的调用之间共享。

因此，对memoize 的每次调用都会返回一个不同的函数以及它自己的cache。对 memoize 返回的特定闭包的后续调用将从 那个 闭包的 cache 插入/获取值。

您可以认为这在某种程度上等同于更老式的 OOP 版本：

template <typename ReturnType, typename... Args>
class Memoize
{
    std::map<std::tuple<Args...>, ReturnType> cache;
public:
    ReturnType operator() (Args... args)
    {
        std::tuple<Args...> t(args...);
        if (cache.find(t) == cache.end())                
            cache[t] = func(args...);
        return cache[t];
    }
};

Answer 2

缓存嵌入到 lambda 本身中，并且是本地的。

因此，如果您创建两个 lambda，则每个都有自己的缓存。

这是实现简单缓存的好方法，因为这样一来，当 lambda 超出范围时，使用的内存就会被清除，并且不会出现内存爆炸。

Answer 3

“这段简单的代码”也可以记忆递归函数，只要它被正确调用。这里我举一个完整的例子：

#include <functional>
#include <iostream>
#include <tuple>
#include <map>

template <typename ReturnType, typename... Args>
std::function<ReturnType (Args...)> memoize(std::function<ReturnType (Args...)> func) {
  std::map<std::tuple<Args...>, ReturnType> cache;
  return ([=](Args... args) mutable {
          std::tuple<Args...> t(args...);
          if (cache.find(t) == cache.end())
             cache[t] = func(args...);
          return cache[t];
  });
}

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

std::function<int (int, int)> b;
int binomial(int n, int k) {
  if (k == 0 || n == k) return 1;
  return b(n-1, k) + b(n-1, k-1);
}

int main(void) {
  f = memoize(std::function<int (int)>(fib));
  std::cout << f(20) << std::endl;
  b = memoize(std::function<int (int, int)>(binomial));
  std::cout << b(34,15) << std::endl;
}

Answer 4

引用您发现此内容的博客，就在代码下方：

...[=] 中的等号表示“捕获 周围的局部变量 按价值划分范围”，这是必需的 因为我们正在返回 lambda 函数，局部变量将 在那一刻消失。

所以，cache 被复制到返回的函数对象中，就好像它是一个成员一样。

（请注意，这段简单的代码将无法记住递归函数。在 C++0x 中实现 fixed-point combinator 留给读者作为练习。）

Answer 5

欢迎来到词法作用域的美妙世界。它可用于创建具有公共和私有成员的整个类型。在函数式语言中，这通常是唯一的方法。

我建议你阅读http://mark-story.com/posts/view/picking-up-javascript-closures-and-lexical-scoping，它是关于 Javascript 的，但 C++0x 为 C++ 添加了相同的概念和（几乎相同的）行为。