如何在遵守德米特法的同時延遲加載？

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只會被調用的素數。