¿Cómo puedo almacenar una expresión lambda como un campo de una clase en C++ 11?

Question

Me gustaría crear una clase donde el cliente pueda almacenar una expresión lambda como []() -> void {} como un campo de la clase, pero no puedo encontrar la manera de hacerlo. One answer suggested using decltype, que probé sin éxito. Aquí hay un ideone source link. El siguiente es el origen y el resultado:

#include <cstdio> 
auto voidLambda = []()->void{}; 

class MyClass { 
public: 
    decltype(voidLambda) t; 
    MyClass(decltype(voidLambda) t) { 
     this->t = t; 
    } 
}; 

int main() { 
    MyClass([] { 
     printf("hi"); 
    }); 
} 

Resultado:

prog.cpp: In constructor 'MyClass::MyClass(<lambda()>)': 
prog.cpp:3:79: error: no matching function for call to '<lambda()>::__lambda0()' 
prog.cpp:2:20: note: candidates are: <lambda()>::<lambda>(const<lambda()>&) 
prog.cpp:2:20: note:     <lambda()>::<lambda>(<lambda()>&&) 
prog.cpp:3:88: error: no match for 'operator=' in '((MyClass*)this)->MyClass::t = t' 
prog.cpp: In function 'int main()': 
prog.cpp:5:27: error: no matching function for call to 'MyClass::MyClass(main()::<lambda()>)' 
prog.cpp:3:48: note: candidates are: MyClass::MyClass(<lambda()>) 
prog.cpp:3:14: note:     MyClass::MyClass(const MyClass&) 

¿Alguien sabe cómo hacer esto?

Answer 1

Si desea que un miembro de clase sea una expresión lambda, considere usar el tipo de envoltorio std::function<> (del encabezado <functional>), que puede contener cualquier función invocable. Por ejemplo:

std::function<int()> myFunction = []() { return 0; } 
myFunction(); // Returns 0; 

De esta forma, no es necesario que conozca el tipo de expresión lambda. Solo puede almacenar un std::function<> del tipo de función apropiado, y el sistema de la plantilla manejará todos los tipos por usted. De manera más general, cualquier entidad invocable con la firma adecuada se puede asignar a std::function<>, incluso si el tipo real de ese functor es anónimo (en el caso de lambdas) o realmente complicado.

El tipo dentro de la plantilla std::function debe ser el tipo de función correspondiente a la función que desea almacenar. Por lo tanto, por ejemplo, para almacenar una función que toma dos int sy devuelve vacía, haría un std::function<void (int, int)>. Para una función que no requiere parámetros y devuelve int, usaría std::function<int()>. En su caso, ya que desea una función que no toma parámetros y devuelve void, te gustaría algo como esto:

class MyClass { 
public: 
    std::function<void()> function; 
    MyClass(std::function<void()> f) : function(f) { 
     // Handled in initializer list 
    } 
}; 

int main() { 
    MyClass([] { 
     printf("hi") 
    }) mc; // Should be just fine. 
} 

Espero que esto ayude!

Answer 2

La única manera que puedo pensar para almacenar una lambda en una clase es utilizar una plantilla con una función de ayuda make_:

expresión

#include <cstdio> 
#include <utility> 

template<class Lambda> 
class MyClass { 
    Lambda _t; 
public: 
    MyClass(Lambda &&t) : _t(std::forward<Lambda>(t)) { 
     _t(); 
    } 
}; 

template<class Lambda> 
MyClass<Lambda> make_myclass(Lambda &&t) { 
    return { std::forward<Lambda>(t) }; 
} 

int main() { 
    make_myclass([] { 
     printf("hi"); 
    }); 
}