lazy initialization with forwarding

Question

Take a "lazy" constructor that might have the following interface:

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;
};

What would be a nice way to implement this?

Answer 1

Here's a little bit of a convoluted way of doing what you want. The basic idea is to have LazyConstruct store the arguments pack in a tuple, and then unpack the tuple on demand to construct 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;
};

I'm making use of C++14's std::index_sequence, if your standard library implementation does not ship this, then there are several examples on SO (this or this) showing how it can be implemented.

Finally a helper function template to construct LazyConstruct instances

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

Live demo

---

Another version based on Alf's answer that uses std::function so that LazyConstruct's type doesn't change based on T's constructor signature.

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

I am not sure about your question, but for lazy initialization I suggest you to use something along the lines of boost::optional<T>. You can delay initialization with it and you will not make use of a pointer and heap memory.

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);

Documentation is here: Boost.Optional

Answer 3

The easiest is probably to just capture the arguments in a lambda.

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;
};

Disclaimer: Code not touched by compiler's hands.

Note: While I'm unable right now to say exactly what's wrong with the idea (it's pretty late), lazy creation doesn't smell right, somehow. I suspect premature optimization.

Answer 4

As per the comment before. You want to delay and capture the arguments.

EDIT: Generalized solution, should work in C++11. Warnings: not tested. apply function is left as an exercise. See here for a possible implementation:

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();
}