The program sorts a vector of strings lexicographically and based on the length of the strings. I used in lines (1) and (2) two function objects from the Standard template library. A function object is an instance of a class for which the call operator (operater ()<\/span>) is overloaded. Often, there are falsely called functors. I hope, you notice the difference between the call std::<\/span>sort(myStrVec.begin(), myStrVec.end(), std::<\/span>less<<\/span>std::<\/span>string><\/span>())<\/span> in line (1) and std::<\/span>sort(myStrVec.begin(), myStrVec.end(), std::<\/span>greater<><\/span>())<\/span>in line (2). The second expression (std::<\/span>greater<><\/span>()<\/span>), in which I provided no type for the predicate, has been valid since C++14. I sorted in lines (3), (4), and (5) by using a function (6), a function object (7), and a lambda function (5). This time, the length of the strings was the sorting criterion.<\/p>\n<\/article>\n For completeness, here is the output of the program.<\/p>\n The rules state you should “Use function objects to pass operations to algorithms”. <\/a><\/span><\/p>\n My argumentation includes three points: Performance, Expressiveness, and State. It makes my answer that lambda functions are function objects under the hood relatively easy. <\/a><\/span><\/p>\n The more the optimizer can reason locally, the more optimization is possible. A function object (4) or a lambda function (5) can be generated just in place. Compare this to a function that was defined in a different translation unit. If you don’t believe me, use the compiler explorer<\/a> and compare the assembler instructions. Of course, compile with maximum optimization.<\/p>\n “Explicit is better than implicit”. This meta-rule from Python also applies to C++. It means that your code should explicitly express its intent. Of course, this holds particularly for lambda functions such as line (5). Compare this with the function lessLength<\/span> in line (6) used in line (3). Imagine your coworker would name the function foo<\/span>; therefore, you have no idea what the function should do. You have to document its usage, such as in the following line.<\/p>\n <\/p>\n Further, you have to hope that your coworker wrote a correct predicate. If you don’t believe him, you must consider the implementation. Maybe that’s not possible because you have the declaration of the function. With a lambda function, your coworker can not fool you. The code is the truth. Let me put it more provocatively: Your code should be such expressive that it needs no documentation. <\/strong><\/p>\n In contrast to a function, a function object can have a state. The code example makes my point.<\/p>\n![\"functionObjects\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/11\/functionObjects.png\")
<\/p>\nAdvantages of function objects<\/h3>\n
Performance<\/h4>\n
Expressiveness<\/h4>\n
\/\/ sorts the vector ascending, based on the length of its strings <\/span>\r\nstd::<\/span>sort(myStrVec.begin(), myStrVec.end(), foo); <\/span>\r\n<\/pre>\n<\/div>\nState<\/h4>\n
\/\/ sumUp.cpp<\/span>\r\n\r\n#include <algorithm><\/span>\r\n#include <iostream><\/span>\r\n#include <vector><\/span>\r\n\r\nclass<\/span> SumMe<\/span>{\r\n int<\/span> sum{0<\/span>};\r\n public:<\/span>\r\n SumMe() =<\/span> default<\/span>;\r\n\r\n void<\/span> operator<\/span>()(int<\/span> x){\r\n sum +=<\/span> x;\r\n }\r\n\r\n int<\/span> getSum<\/span>(){\r\n return<\/span> sum;\r\n }\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n std::<\/span>vector<<\/span>int<\/span>><\/span> intVec{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>, 9<\/span>, 10<\/span>}; \r\n\r\n SumMe sumMe=<\/span> std::<\/span>for_each(intVec.begin(), intVec.end(), SumMe()); \/\/ (1)<\/span>\r\n\r\n std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>\"<\/span>;\r\n std
![\"contract\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/11\/contract.png\")
<\/p>\n