懒惰在C++ 11

Question

你知道如何在这个d片断执行字符串的懒惰评价，如：

void log(lazy string msg) { 
    static if (fooBarCondition) 
    writefln(…) /* something with msg */ 
} 

其实，这个问题可能不需要懒惰，因为在所有的静态如果。不使用时可能会丢弃char const*字符串？喜欢，在C++中：

void log(char const *msg) { 
    #ifdef DEBUG 
    cout << … << endl; /* something with msg */ 
    #else /* nothing at all */ 
    #endif 
} 

任何想法？谢谢。

Answer 1

#ifdef DEBUG 
#define log(msg) do { cout << … << endl; } while(0) 
#else 
#define log(msg) do { } while(0) 
#endif 

有两种方法可以在C++ 11中实现懒惰：宏和lambda表达式。技术上两者不是“懒惰的”，而是所谓的“正常评估”（与“渴望评估”相反），这意味着可以多次评估表达式。因此，如果您将程序从D（或haskell）转换为C++，则必须注意不要在这些表达式中使用带副作用的表达式（包括计算时间）。

要实现真正的懒惰，你将不得不实施记忆，这并不那么简单。

对于简单的日志记录，宏只是很好。

Answer 2

尽管Elazar的答案有效，但我并不希望为此使用宏（尤其是不包含所有小写名称的宏）。 这里是我会做什么，而不是：

template<bool /* = false */> 
struct logger_impl { 

    template<typename T> 
    static std::ostream & write(std::ostream & stream, T const &) { 
     return stream; 
    } 
}; 

template<> 
struct logger_impl<true> { 

    template<typename T> 
    static std::ostream & write(std::ostream & stream, T const & obj) { 
     return stream << obj; 
    } 
}; 

template<typename T> 
void log(T const & obj) { 
#if defined(NDEBUG) 
    logger_impl<true>::write(std::cout, obj); 
#else 
    logger_impl<false>::write(std::cout, obj); 
#endif 
} 

只是我的2美分。

Answer 3

你可以混合宏和lambda表达式来产生这种效果

你可以有一个类型，懒惰

template<class T> 
class lazy { 
    ... 
} 

，然后你可以有一个使用Lambda

创建的其中一个慵懒的包装

#define LAZY(E) my_lazy_type<decltype((E))>([&](){ return E; }) 

所有my_lazy_type需求都是一个接受std :: function的构造函数，以及一个operator（）的重载函数，用于计算并返回它。在每次评估中，您可以用一个只返回已经计算的值的thunk替换该thunk，因此它只会计算一次。

编辑： 这里是我正在谈论的一个例子。不过，我想指出，这不是一个完美的例子。它通过价值在一堆懒散的东西中传递了一堆东西，这可能完全破坏了首先这样做的目的。它内部使用可变内存，因为我需要能够在常量情况下记忆thunk。这可以在许多方面得到改善，但它是一个体面的概念证明。

#include <iostream> 
#include <functional> 
#include <memory> 
#include <string> 

#define LAZY(E) lazy<decltype((E))>{[&](){ return E; }} 

template<class T> 
class lazy { 
private: 
    struct wrapper { 
     std::function<T()> thunk; 
     wrapper(std::function<T()>&& x) 
      : thunk(std::move(x)) {} 
     wrapper(const std::function<T()>& x) 
      : thunk(x) {} 
    }; 
    //anytime I see mutable, I fill a bit odd 
    //this seems to be warented here however 
    mutable std::shared_ptr<wrapper> thunk_ptr; 
public: 
    lazy(std::function<T()>&& x) 
     : thunk_ptr(std::make_shared<wrapper>(std::move(x))) {} 
    T operator()() const { 
     T val = thunk_ptr->thunk(); 
     thunk_ptr->thunk = [val](){return val;}; 
     return val; 
    } 
}; 

void log(const lazy<std::string>& msg) { 
    std::cout << msg() << std::endl; 
} 

int main() { 
    std::string hello = "hello"; 
    std::string world = "world"; 
    log(LAZY(hello + ", " + world + "!")); 
    return 0; 
}