如何在遵守得墨忒耳定律的同时延迟加载？

Question

我愿意遵守得墨忒耳法则。但我也想延迟加载一些传递给构造函数的对象。我应该如何实施？传递一个包装类？传递函数指针？

Answer 1

您实际上可以编写一个通用包装器来完成此操作：

template <typename T>
class Lazy {
public:
  explicit Lazy(T const& t): _loader(), _item(t) {}
  explicit Lazy(T&& t): _loader() _item(t) {}
  explicit Lazy(std::function<T()> l): _loader(l), _item() {}

  T& operator*() { return this->get(); }
  T const& operator*() const { return this->get(); }

  T* operator->() { return &this->get(); }
  T const* operator->() const { return &this->get(); }

private:
  T& get() { if (not _item) { _item = _loader(); } return *_item; }
  T const& get() const { if (not _item) { _item = _loader(); } return *_item; }

  std::function<T()> _loader;
  mutable boost::optional<T> _item;
}; // class Lazy

这个类保证加载器执行一次，只要它完成。如果它没有完成，那么将在下一次访问时重试执行。它不是线程安全的。

用法：

// Output prime numbers as text
bool isPrime(int);
std::string toEnglish(int);

void print(int i, Lazy<std::string> const& heavy) {
    if (not isPrime(i)) { return; }

    std::cout << *heavy << "\n";
}

int main(int argc, char* argv[]) {
    if (argc < 2) { return 1; }

    int max = atoi(argv[1]);
    for (int i = 2; i <= max; ++i) {
        print(i, [=](){ return toEnglish(i); });
              // ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++11 lambda syntax
    }
}

这里，toEnglish 只对素数调用。