chiusura C++ e std :: function

Question

Sto cercando di capire cosa succede sotto il cofano di std :: function quando usato in combinazione con chiusure. Non riesco ancora a capirlo, ad esempio: quale costruttore viene chiamato? Qualcuno può pubblicare un esempio funzionante di una caduta minimalista nella sostituzione di std :: function che supporta la funzionalità necessaria nel seguente esempio?

#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

Ecco l'esempio minimalista:

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

L'idea di base è quella di utilizzare cancellazione di tipo per memorizzare la chiusura effettiva senza conoscere il tipo: vedere il virtual Impl::operator() e localmente definito di tipo specifico titolare ConcreteImpl.

Live example