Violation d'accès sur std :: function assignée à un lambda

Question

J'essayais de jouer avec std :: function et std :: bind et j'ai posé un problème. Je voudrais construire une structure générale qui me permet de lier une fonction std :: à une fonction membre sans connaître a priori les arguments de la fonction membre. J'ai écrit cette chose

template<typename Class, typename Return, typename ...Args> 
struct Caller 
{ 
private: 
    std::function<Return(Args ...)> callerFunction; 

    Caller(const Caller&) = delete; 
    Caller(Caller&&) = delete; 
    Caller& operator=(const Caller&) = delete; 

public: 
    ~Caller() = default; 
    Caller() = default; 

    Caller(Class& instance, Return(Class::*function)(Args...)) 
    { 
     callerFunction = [&](Args... args) { return (instance.*function)(args...); }; 
    } 

    Return operator() (Args ... args) 
    { 
     return callerFunction(args...); 
    } 
}; 

Pour votre information, je sais que les arguments de la fonction sont passés par valeur (je rencontrais un problème en utilisant des références universelles avec modèle variadique, je travaillerai plus tard).

Le problème ici est que lorsque j'exécute la fonction avec operator(), j'obtiens une erreur de violation d'accès. J'ai essayé d'affiner le problème et de créer une structure sans les arguments variadiques (permettant à la fonction membre d'avoir juste un argument int) et j'ai vu que l'assignation du lambda à la fonction std :: me donnait la même erreur, mais J'ai utilisé std :: bind avec un espace réservé tout allait bien.

Le terrain d'essai est ce

class A 
{ 
public: 
    bool foo(int a) 
    { 
     std::cout << a << std::endl; 
     return true; 
    } 
}; 

int main() 
{ 
    A a; 
    a.foo(9); 

    Caller<A, bool, int> caller(a, &A::foo); 
    caller(10); 

    std::cin.ignore(); 
} 

En utilisant le lambda, dois-je enregistrer l'instance de la classe pour appeler correctement la fonction de membre?

Answer 1

Comme état dans le commentaire, vous avez pointeur ballants de function, vous pouvez utiliser à la place:

Caller(Class& instance, Return(Class::*function)(Args...)) 
{ 
    callerFunction = [&instance, function](Args... args) { 
     return (instance.*function)(std::forward<Args>(args)...); 
    }; 
} 

Note: instance devrait également Caller survit.

Answer 2

N'utilisez pas [&] lorsque l'objet ou les copies de celui-ci survivent à la portée actuelle.

Vous capturez des références aux variables locales et vous les stockez au-delà de la portée actuelle.