延遲初始化與轉發

Question

採取「偷懶」的構造函數，可能有以下接口：

template<class T> 
struct LazyConstruct { 
    // accept any number of arguments, 
    // which would later be used to construct T 
    template<class... U> 
    LazyConstruct(U&&... u) { 
     // store the arguments somehow 
    } 
    T& get() { 
     if(!data) data.reset(new T(/* unpack the arguments */)); 
     return *data; 
    } 
private: 
    std::unique_ptr<T> data; 
}; 

什麼是實現這個的好方法？

Answer 1

這裏有一點點複雜的做你想做的事情。基本想法是讓LazyConstruct將參數包存儲在tuple中，然後根據需要解壓tuple以構建T。

template<class T, class... Args> 
struct LazyConstruct { 
    // accept any number of arguments, 
    // which would later be used to construct T 
    template<class... U> 
    LazyConstruct(U&&... u) 
    : args(std::make_tuple(std::forward<U>(u)...)) 
    { 
    } 

    T& get() { 
     if(!data) data = create(std::index_sequence_for<Args...>()); 
     return *data; 
    } 

    template<std::size_t... I> 
    std::unique_ptr<T> create(std::index_sequence<I...>) 
    { 
     return std::unique_ptr<T>{new T(std::get<I>(args)...)}; 
    } 

private: 
    std::tuple<typename std::decay<Args>::type...> args; 
    std::unique_ptr<T> data; 
}; 

我正在使用C++ 14的std::index_sequence，如果你的標準庫實現不出貨這一點，那麼有上顯示它是如何實現的SO（this或this）的幾個例子。

最後一個輔助函數模板構建LazyConstruct實例

template<class T, class... Args> 
LazyConstruct<T, Args...> make_LazyConstruct(Args&&... args) 
{ 
    return LazyConstruct<T, Args...>{std::forward<Args>(args)...}; 
} 

Live demo

---

基於Alf's answer另一個版本，它使用std::function，使LazyConstruct的類型不更改基於T「的構造函數簽名。

template<class T> 
struct LazyConstruct { 
    template<class... Args> 
    LazyConstruct(Args&&... args) 
    : holder([this, args = std::make_tuple(std::forward<Args>(args)...)]() { 
      return create(std::index_sequence_for<Args...>(), std::move(args)); 
     }) 
    { 
    } 

    T& get() { 
     if(!data) data = holder(); 
     return *data; 
    } 

    template<std::size_t... I, class Tuple> 
    std::unique_ptr<T> create(std::index_sequence<I...>, Tuple args) 
    { 
     return std::unique_ptr<T>{new T(std::get<I>(args)...)}; 
    } 

private: 
    std::function<std::unique_ptr<T>()> holder; 
    std::unique_ptr<T> data; 
}; 

Live demo

Answer 2

我不確定你的問題，但對於懶惰的初始化，我建議你沿着boost::optional<T>的方向使用一些東西。你可以延遲初始化，你不會使用指針和堆內存。

class MyClass { 
public: 
    void f(); 
}; 

void anotherFunc(MyClass & c); 

boost::optional<MyClass> mc; //Not initialized, empty, stack memory. 

mc = MyClass{}; 
if (mc != boost::none) 
    mc->f(); 
anotherFunc(*mc); 

文檔是在這裏：Boost.Optional

Answer 3

最簡單的可能是剛剛拍攝參數的拉姆達。

template<class T> 
struct LazyConstruct { 
    // accept any number of arguments, 
    // which would later be used to construct T 
    template<class... U> 
    LazyConstruct(U&&... u) 
     : create([=]() -> T* { return new T(u...); }) 
    {} 
    T& get() { 
     if(!data) data.reset(data.reset(create())); 
     return *data; 
    } 
private: 
    std::unique_ptr<T> data; 
    std::function<auto()->T*> create; 
}; 

聲明：編碼器未觸及的代碼。

注意：儘管我現在無法準確地說出這個想法到底出了什麼問題（這很晚了），但懶惰的創作不知道是否正確。我懷疑過早的優化。

Answer 4

按照之前的評論。你想延遲並捕捉這些論據。

編輯：廣義的解決方案，應該在C++ 11中工作。警告：未經測試。應用功能留作練習。一個可能的實現見here：

template <class T> 
struct make { 
    template <class...Args> 
    T operator()(Args &&... args) const { 
     return T(std::forward<Args>(args)...); 
    } 
}; 


template <class T, class... Args> 
struct object_builder { 

    object_builder(Args... && args) : 
     captured_args_(std::forward<Args>(args)...) {} 

    T operator()() const { 
     return apply(make<T>{}, 
       captured_args_); 
} 

private: 
    std::tuple<Args...> captured_args_; 
}; 


template <class T, class...Args> 
object_builder<T, Args...> make_object_builder(Args &&...args) { 
    return object_builder<T, Args...>(std::forward<Args>(args)...); 
} 

int main() { 
    //Create builders with captured arguments 
    auto scary_monster_builder = 
     make_object_builder<Monster>(scary, "big orc"); 
    auto easy_monster_builder = make_object_builder<Monster>(easy, 
                 "small orc"); 

    //Instantiate objects with the captured arguments from before 
    auto a_scary_monster = scary_monster_builder(); 
    auto an_easy_monster = easy_monster_builder(); 
}