Using functors with STL algorithms versus lambda expressions?

Question

Stroustrup gives the example of using an overloaded operator() to execute a function on vector elements during a transform operation:

class Example
{
  public:
   std::vector<int> Test1 {1,2,3,4,5};
   std::vector<int> Test2;
   int operator()(int el);
   void MyFunction();
}

int Example::operator()(int el)
{
  return el + 1;
}

void Example::MyFunction()
{
std::transform(Test1.begin(), Test1.end(), std::back_inserter(Test2), std::bind(Example(), std::placeholders::_1))
}

However, with the introduction of lambda expressions the above code seems very verbose, compared to:

std::transform(Test1.begin(), Test1.end(), std::back_inserter(Test2), [](int el){return el + 1;});

Am I right in saying there is little value in using the overloaded operator() approach? Or are there still scenarios where they can be beneficial when working with STL algorithms?

Your title is generic - operator overloading - but you actually mean operator() overloading, and even more precisely, using functors. I will edit the question. — SergeyA, Dec 09 '16 at 19:07

score 2 · Accepted Answer · answered Dec 09 '16 at 18:58

Yes you're right.

A lambda expression basically creates a nameless functor. It just allows the programmer to do it in less code. Before C++11 the standard algorithms could only work with functors which would require the programmer to set up a whole new class just for some specific behaviour (like you just did).

This is exactly the reason why lambda's were introduced into C++11, to make sure using the standard algorithms with a custom functor weren't such a pain to write anymore.

score 0 · Answer 2 · answered Dec 09 '16 at 19:18

As Gill Bates mentions, you are correct, the lambda expression does create a nameless functor. However, it can also makes code considerably more difficult to read. I've found that, in collaborative projects, it's often clearer to just overload the operator if something is used more than once, especially if something complicated is going on.

On that note, lambdas are good if you use them sparingly. For functionality that is vital and often used with your object, you may want to encapsulate all such interactions in an overloaded operator.

Using functors with STL algorithms versus lambda expressions?

2 Answers2