When to use functors over lambdas

by

A lambda is a functor – just defined with a shorter syntax.

The problem is that this syntax is limited. It doesn’t always allow you to solve a problem in the most efficient and flexible way – or at all. Until C++14, the operator() couldn’t even be a template.

Furthermore, a lambda has exactly one operator(). You can’t provide several overloads to distinguish between, say, the types of the arguments:

struct MyComparator
{
    bool operator()( int a, int b ) const {return a < b;}
    bool operator()( float a, float b ) const {return /*Some maths here*/;}
};

.. or value category of the object argument (that is, the closure object that is called). You can also not define special member functions, including constructors and destructors – what if a functor shall be responsible for resources?

Another problem with lambdas is that they cannot be recursive. Of course, normal functions (including operator functions) can be.

Also consider that lambdas are unhandy to use as comparators for associative containers or deleters for smart pointers: You can’t directly pass the closure type as a template argument and need to construct the containers member from another closure object. (Closure types don’t have a default constructor!). For a block-scope map that isn’t too much of a hassle:

auto l = [val] (int a, int b) {return val*a < b;};
std::map<int, int, decltype(l)> map(l);

Now, what happens if your map is a data member? What template argument, what initializer in the constructors initialization list? You’d have to use another static data member – but since you have to define it outside the classes definition that is arguably ugly.

To sum up: Lambdas aren’t useful for more complex scenarios because they weren’t made for them. They provide a short and concise way of creating simple function objects for correspondingly simple situations.

More Related Contents:

  1. Declaring lambda with int type not working [closed]
  2. C++ lambda with captures as a function pointer
  3. Move capture in lambda
  4. Passing capturing lambda as function pointer
  5. What is the type of lambda when deduced with “auto” in C++11?
  6. How is std::function implemented?
  7. Why can lambdas be better optimized by the compiler than plain functions?
  8. Bind Vs Lambda?
  9. How do I get the argument types of a function pointer in a variadic template class?
  10. C++0x lambda capture by value always const?
  11. C++11 lambda implementation and memory model
  12. Can lambda functions be templated?
  13. Error: variable “cannot be implicitly captured because no default capture mode has been specified”
  14. Lambda capture as const reference?
  15. Lifetime of lambda objects in relation to function pointer conversion
  16. Why can’t I capture this by-reference (‘&this’) in lambda?
  17. Lambda expressions as class template parameters
  18. How to immediately invoke a C++ lambda?
  19. std::remove_if – lambda, not removing anything from the collection
  20. Lambda functions as base classes
  21. How do static variables in lambda function objects work?
  22. Lambdas and capture by reference local variables : Accessing after the scope
  23. Are lambdas inlined like functions in C++?
  24. How can I pass a C++ lambda to a C-callback that expects a function pointer and a context?
  25. Specializing a template on a lambda in C++0x
  26. C++11 Change `auto` Lambda to a different Lambda?
  27. how to specify vc11 lambda calling convention
  28. Can using a lambda in header files violate the ODR?
  29. Can the ‘type’ of a lambda expression be expressed?
  30. When can we omit the return type in a C++11 lambda?

Leave a Comment