我应该使用 Initialize-on-demand 习语吗？如果可以，如何使用？

Question

我有以下代码：

 MyType x = do_something_dangerous();
 // ...
 if (some_condition) {
     // ...
     bar(x);
 }
 else { 
     // ...
 }
 // ...
 if (another_condition_which_may_depend_on_previous_if_else} {
     // ...
     baz(x);
 }

这个想法是，在某些情况下，可能很难/不方便提前确定，我需要使用x。但在我不需要使用它的情况下，尝试初始化它可能会很糟糕（比如说，可能会使我的进程崩溃）。

现在，看来我需要使用的是initialize-on-demand holder（链接侧重于Java，所以这是一个草图）：某种Wrapper<MyType> 或Wrapper<MyType, do_something_dangerous> 与get() 方法，例如第一个 get() 调用 do_something_dangerous() 和后来的 get()s 只是传递第一个调用获得的值。

• 这确实是一种合适的方法吗？
• 这个成语是否有一些标准（ish）实现，或者它的变体？

注意事项：

• 我可以使用boost::optional，但这会有点麻烦并且还会扭曲预期用途：“建议在只有一个明确（对所有各方）理由的情况下使用optional<T>没有 T 类型的值，并且缺少值与具有任何常规值 T 一样自然。"

Answer 1

恕我直言，您提出的解决方案非常合适：

• 实现起来很简单
• 完全满足您的需求

当然，如果您已经在应用程序中使用了 boost，您可以查看建议的 boost::optional 模块，但我不确定它是否正是您想要的，因为它更多地是为可空对象设计的需要延迟初始化。

我的建议是：坚持使用专用的包装器实现。

与其他答案不同，我认为您应该不使用单例，而只是使用类似（使用初始化参数实现）：

template<typename T, typename I>
class LazyInit {
    T* val;
    I init;

public:
    LazyInit<T, I>(I init): init(init) {
        val = NULL;
    }
    ~LazyInit<T, I>() {
        delete val;
        val = NULL; // normally useless here
    }
    T& get() {
        if (val == NULL) {
            val = new T(init);
        }
        return *val;
    }
};

这是一个使用初始化函数的实现：

template<typename T>
class LazyInit {
    T* val;
    T (*init)();

public:
    LazyInit<T>(T (*init)()): init(init) {
        val = NULL;
    }
    ~LazyInit<T>() {
        delete val;
        val = NULL; // normally useless here
    }
    T& get() {
        if (val == NULL) {
            val = new T(init());
        }
        return *val;
    }
};
...
LazyInit<MyType> x(do_something);
...
bar(x.get()); // initialization done only here

您可以轻松地将两者结合起来，使用带参数的函数构建实现。

Answer 2

如果你有 c++11，你可以使用 std::async 和 std::shared_future 的组合：

#include <iostream>
#include <future>

using namespace std;

struct LazyObj {
    LazyObj() {
        cout << "LazyObj init" << endl;
    }
    void test() {
        cout << "LazyObj test" << endl;
    }
};

int main() {
    auto x = std::async(launch::deferred, []() -> LazyObj& {
        static LazyObj a;
        return a;
    }).share();

    int cond=0;
    if( cond == 0 ) {
        x.get().test();
        x.get().test();
    }
    return 0;
}

在这个用例中launch::deferred 指向std::async 不创建执行线程并在调用get() 时按需调用lambda。为了允许多次调用get() 方法，我们使用share() 方法将std::future 转换为std::shared_future。现在我们可以在需要的时间或地点获取惰性初始化对象。