Lavavej for his 2015 CppCon talk, where I learned this aspect of std::function.
And to achieve this, there is a delicate mechanism involving runtime polymorphism and indirections, that has some cost.
This allows to store such std::functions in a vector for example, which we don’t need here. The power of std::function is that it represents a value that can wrap various types of callable entities (free function, member function, function object) in the same type. That sounds more reasonable.Įither way, the point is that std::function is too powerful (and as a result, needlessly complex and costly) for the usage we’re making of it. Let’s not get carried away, let’s just say using a hammer to swat an ant. So here it would be a function taking a const object of type X (indeed, getValue is a const member function of X) and returning an int, hence the template type.īut using std::function here is like using a steamroller to swat an ant. In the case of a member function it is a little different: it is essentially the type of what would have been that member function if it were taken out of the class and turned into a free function. In the general case, the template type of std::function is the type of the wrapped function. Std::function accepts pretty much anything that is callable (free functions, member functions, function objects) and wraps it in an object defining an operator() that forwards the call to the wrapped callable thing. To understand why, here is a brief recap of how std::function works. The most famous one is probably std::function, that appeared in C++11: std::transform(begin(inputs), end(inputs), back_inserter(results), std::function(&X::getValue)) Instead of rolling out a lambda, we can think of using the function objects provided by the standard library. Note that using std::bind is in the same spirit but with even more noise and has all the disadvantages of using std::bind over using lambdas explained in item 34 of Effective Modern C++. Indeed, the syntax of the lambda adds noise to the code and needlessly introduces a new object, input, that is at a lower level of abstraction than the surrounding code working at the level of the whole collection). While this is conceptually simple and does the right thing, this is a sub-optimal solution. For example, with std::transform, we can write code like this: auto const inputs = std::vector) The C++ standard library makes it easy to use free functions with its STL algorithms.
0 kommentar(er)
