c++ closure and std::function

Question

I'm trying to figure out what goes on under the hood of std::function when used in combination with closures. I'm not able to wrap my head around it yet, for example: what constructor is being called? Can anybody post a working example of a minimalistic drop in replacement of std::function that supports the functionality needed in the following example?

#include <functional>

int main(int argc, char* argv[])
{
    int mybool = 5;

    auto foo = [&] (int arg) {
        return mybool * arg;
    };

    std::function<int(int)> foo2 = foo;

    int result = foo2(42);

    return 0;
}

Answer 1

Here's the minimalistic example:

template <class F>
struct Decomposer;

template <class R, class A>
struct Decomposer<R (A)>
{
  typedef R return_type;
  typedef A argument_type;
};


template <class F>
struct my_function
{
  typedef typename Decomposer<F>::return_type return_type;
  typedef typename Decomposer<F>::argument_type argument_type;

  return_type operator() (argument_type arg) const {
    return (*impl)(arg);
  }

  template <class From>
  my_function(From &&from)
  {
    struct ConcreteImpl : Impl
    {
      typename std::remove_reference<From>::type functor;
      ConcreteImpl(From &&functor) : functor(std::forward<From>(functor)) {}
      virtual return_type operator() (argument_type arg) const override
      {
        return functor(arg);
      }
    };
    impl.reset(new ConcreteImpl(std::forward<From>(from)));
  }

private:
  struct Impl {
    virtual ~Impl() {}
    virtual return_type operator() (argument_type arg) const = 0;
  };

  std::unique_ptr<Impl> impl;
};

The core idea is to use type erasure to store the actual closure without knowing its type: see the virtual Impl::operator() and locally-defined type-specific holder ConcreteImpl.

Live example