Copy-construct and later access arbitrary POD types

Question

I'd like to fill in the store() and launch() methods in the below code. The important detail which captures the spirit of the problem is that the object foo declared in main() no longer exists at the time we call launch(). How can I do this?

#include <cstdio>
#include <cstring>
#include <type_traits>

template<typename T, typename U=
  typename std::enable_if<std::is_trivially_copyable<T>::value,T>::type>
struct Launchable {
  void launch() { /* some code here */ }

  T t;
  // other members as needed to support DelayedLauncher 
};

class DelayedLauncher {
public:
  template<typename T>
    void store(const Launchable<T>& t) {
      // copy-construct/memcpy t into some storage
    }

  void launch() const {
    // call t.launch(), where t is (a copy of) the last value passed into store()
  }

  // other members as needed
};

int main() {
  DelayedLauncher launcher;
  {
    Launchable<int> foo;
    launcher.store(foo);
  }
  launcher.launch();  // calls foo.launch()
  return 0;
}

Note that if we only had a fixed set of N types to pass into store(), we could achieve the desired functionality by declaring N Launchable<T> fields and N non-template store() methods, one for each type, along with an enum field whose value is use in a switch statement in the launch() method. But I'm looking for an implementation of DelayedLauncher that will not need modification as more Launchable types are added.

Answer 1

using std::function:

class DelayedLauncher {
public:
  template<typename T>
    void store(const Launchable<T>& t) {
      f = [t]() {t.launch();};
    }

  void launch() const { f(); }

 private:
     std::function<void()> f;
};

Answer 2

You could give Launchable a base class with a virtual launch() and no template, and store pointers to that base class in Launcher::store.

EDIT: Adapted from @dshin's solution:

struct LaunchableBase {
    virtual void launch() = 0;
};

template<typename T, typename U=
  typename std::enable_if<std::is_trivially_copyable<T>::value,T>::type>
  struct Launchable : public LaunchableBase {
      virtual void launch() override { /* some code here */ }

      T t;
      // other members as needed to support DelayedLauncher 
  };

class DelayedLauncher {
    public:
        template<typename T>
            void store(const Launchable<T>& t) {
                static_assert(sizeof(t) <= sizeof(obj_buffer),
                        "insufficient obj_buffer size");
                static_assert(std::is_trivially_destructible<T>::value,
                        "leak would occur with current impl");
                p = new (obj_buffer) Launchable<T>(t);
            }

        void launch() const {
            p->launch();
        }

    private:
        char obj_buffer[1024];  // static_assert inside store() protects us from overflow
        LaunchableBase *p;
};

Answer 3

I believe this variant of Jarod42's solution will avoid dynamic allocation, although I would appreciate if someone could confirm that this will work the way I think it will:

class DelayedLauncher {
public:
  template<typename T>
    void store(const Launchable<T>& t) {
      static_assert(sizeof(t) <= sizeof(obj_buffer),
        "insufficient obj_buffer size");
      static_assert(std::is_trivially_destructible<T>::value,
        "leak would occur with current impl");
      auto p = new (obj_buffer) Launchable<T>(t);
      auto ref = std::ref(*p);
      f = [=]() {ref.get().launch();};
    }

  void launch() const {
    f();
  }

private:
  char obj_buffer[1024];  // static_assert inside store() protects us from overflow
  std::function<void()> f;
};

I believe it should work because the resources I've looked at indicate that std::function implementations typically have a "small capture" optimization, only triggering a dynamic allocation if the total size of the captured data exceeds some threshold.

---

EDIT: I replaced my code with a version provided by Jarod42 in the comments. The standard guarantees the above implementation will not trigger dynamic allocation.