Using lambdas in template class

Your example doesn't work because F is a type, not a callable object. The next step is to instantiate it by creating a member variable.

template <class F> class A { F function; public: int f(int i) { return function(i); } }; 

However, that still won't work because lambda default constructors are deleted. That means we need another way to construct function. That can be achieved by passing an argument to A's constructor.

template<typename F> class A { F function; public: A(const F& f) : function(f) {} int f(int i) { return function(i); } }; // ... auto f = [](int i) { return i+5; }; A<decltype(f)> a(f); 

This uses the lambda copy constructor, which isn't deleted.

Live example

If you want it to work with any lambda, you can add some more magic.

template<typename F> class A { F function; public: A(const F& f) : function(f) {} template<typename ...Args> auto f(Args... args) -> std::result_of_t<F(Args...)> { return function(std::forward<Args>(args)...); } }; 

Live example

If you really want to use template in order to accept any kind of function's signature, then the implementation should be something similar to this:

class A { public: template<typename F, typename... Args> auto f(F&& funct, Args&&... args) { return funct(std::forward<Args...>(args)...); } }; 

That because you've said in the comment:

Q: Does the type F is needed in the class of only for method f?
A: only the method.

Because of that, it should be useless to have a template class, when you can just have a template method.

An here, an example how to call the method which just invoke the "callable object with its parameters", in this case a lambda function:

int main(int argc, char* argv[]) { A a; a.f([](int i) -> int { return i + 5; }, 12); // |------callable object-----------| |argument of function| return 0; } 

Practically, the method f accepts as first argument a "callable object" and as further arguments any parameters requested in order to invoke the first argument.

Additional Notes:

If you want to pass to method f a certain type of signature of function, for example: int (*)(int), then you can avoid using template and pass an object of type std::function.

This is just an example:

#include <functional> class A { public: // method g accept a function which get a integer and return an integer as well. int g(std::function<int(int)> funct, int arg) { return funct(arg); } }; 

It's not enough to define A as inherited from or somehow containing a lambda function, you still have to initialize the subobject when you create an instance of A.
To do that, as an example, you can inherit from the lambda and use A as a callable object.
It follows a minimal, working example:

#include <iostream> using namespace std; template <class F> class A: public F { public: A(F f): F(f) {} }; int main() { auto f = [](int i){return i+5;}; A<decltype(f)> a{f}; cout << a(5); return 0; } 

You don't have to define any function f to execute the lambda.
Anyway, if you want to have a function f to be called as a.f(5), you can define it as it follows:

int f(int i) { return F::operator()(i); } 

Or as it follows:

int f(int i) { return (*this)(i); }