The main reason for function pointers is to provide generic callable objects, but in C++ 11 the way to provide it would be to use std::function, so is there any reason to use function pointers in modern C++ apart from compatibility with C? In other words, is std::function a modern version of function pointers, exactly like std::array vs built-in arrays?
4 Answers
Yes I'd prefer std::function nearly everywhere but there are few cases where size overhead and indirection of std::function may not be acceptable. For small callables like function pointers wrapped in std::function, there is typically no additional indirection and no dynamic memory allocation since the callable fits into the std::function but std::function may be big to hold even bigger callables so there may be a big space overhead.
3 Comments
Jerry101
When would you use
std::function instead of just lambda expressions? When you want to be able to provide other kinds of implementations and you don't want to do that by wrapping them in lambdas?
TNA
@Jerry101 Yes like function pointers I use them to switch between different Implementations or to let a caller provide some kind of functionality like a callback. You can't do this with lambdas since every lambda has it's own type.
BenPope
The main purpose of std::function is type erasure and adaptation. Function pointers have a strict type. std::function is a polymorphic function wrapper, it can bind to a free function, a class static function, a member function, and it can be used for partial function application, etc. If you don't need all of that, it probably isn't the right tool for the job, the type-erasure doesn't come free, often involving virtual calls and heap allocation (although typically there is a small buffer optimisation).
To be honest, I can't think of a case where I'd need std::function, and here's why. If I'm bouncing function pointers around at all, then I'm probably working at a very low level. Perhaps the reason is that C++-style inheritance has proven too restrictive so I'm designing my own polymorphism. Alternatively, I might be working on a small embedded controller where I'm really shaving off the bytes. Either way, I'll be relying on myself, and not on the compiler, to remember what types I've got etc. I'd basically be banging metal and want the metal to behave like metal, not like an elevator from Sirius Cybernetics.
The only case where I'm likely to want the overhead of std::function is if I'm trying to do something functional, like juggling closures, but if I want that then I'm unlikely to be using C++ at all.
2 Comments
Eugene
Java Script is nothing but closures and function pointers. I wouldn't call that programming style "low level". :) Elements of functional programming are potentially useful regardless of how low a level you find yourself on.
RamblingMad
anything remotely similar to an event based system would probably be much better with
std::function rather than plain function pointers. Passing in void* parameters and casting is not usually preferred :POn POSIX systems you get dlopen & dlsym and you would use them to get function pointers from dynamically loaded plugins.
This is a common use case where function pointers are still useful, even with C++14 (see e.g. Qt)
And as many people observed, the implementation of closures (or of std::function) would often require extra indirections and extra runtime costs.
answered Sep 11, 2015 at 8:31
Basile Starynkevitch
231k18 gold badges323 silver badges578 bronze badges
Comments
std::function is very handy and efficient for most use cases. But there is a missing feature: equality.
So, every time you need to compare/filter/search for/sort std::function like objects, you have to fall back to function pointers to implement what you need.
2 Comments
Basile Starynkevitch
Equality of functions is somehow undecidable, if you care about their observable behavior only
Stas
Sure, that's why
std::function objects can't be compared)
std::functionshave extra indirections and aren't for free.std::functionobject is not equivalent to a function pointer, but you can initialize astd::functionobject with a function pointer. Instead it's a callable object that can wrap other callable objects, and yes in most cases it's preferred as it can handle all kind of other callable objects (function pointers, member function pointers, lambdas, other callable objects, etc.).std::arrayis incorrect,std::arrayhas zero overhead compared to a raw array.