std-function

Many standard library algorithms take predicate functions. However, the type of these predicates is an arbitrary, user-provided template parameter. Why doesn't C++11 specify that these take a specific type, like std::function instead? For example: template< class InputIt > InputIt find_if( InputIt first, InputIt last, std::function<bool()> p ); Isn't using this instead of a template as argument type not much more clean? std::function is for runtime polymorphism. Any particular std::function instance could be storing a functor of any type (a type that's appropriate for the std::function 's

Library code: class Resource { public: typedef void (*func_sig)(int, char, double, void*); //Registration registerCallback(void* app_obj, func_sig func) { _app_obj = app_obj; _func = func; } //Calling when the time comes void call_app_code() { _func(231,'a',432.4234,app_obj); } //Other useful methods private: void* app_obj; func_sig _func; //Other members }; Application Code: class App { public: void callme(int, char, double); //other functions, members; }; void callHelper(int i, char c, double d, void* app_obj) { static_cast<App*>(app_obj)->callme(i,c,d); } int main() { App a; Resource r; r

I am currently working on a library where I am chaining function objects. I am creating a function template that takes a callable object (std::function at the moment) and is parametrized on the output and input type of the function. Here is a simplified version of what I am defining: template <typename In, typename Out> std::vector<Out> process(std::vector<In> vals, std::function< Out(In) > func) { // apply func for each value in vals return result; } The problem I am having is on usage. It seems that when I pass a lambda, the compiler cannot deduce the type correctly, so complains that the

I have seen quite a few similar questions, but have not found a solution to my particular problem. I am attempting to SWIGify some C++11 code that uses std::function, so I can use it in my Java application. I have encountered shared pointers like this: virtual std::shared_ptr<some::ns::TheThing> getTheThing(unsigned short thingID); and successfully handled them with the shared_ptr directive like so: %shared_ptr(some::ns::TheThing); I have encountered vectors of shared pointers like this: virtual std::vector<std::shared_ptr<some::ns::TheThing>> getAllTheThings() const = 0; and successfully

Is there a way to std::bind to a std::weak_ptr ? I'd like to store a "weak function" callback that automatically "disconnects" when the callee is destroyed. I know how to create a std::function using a shared_ptr: std::function<void()> MyClass::GetCallback() { return std::function<void()>(std::bind(&MyClass::CallbackFunc, shared_from_this())); } However the returned std::function keeps my object alive forever. So I'd like to bind it to a weak_ptr : std::function<void()> MyClass::GetCallback() { std::weak_ptr<MyClass> thisWeakPtr(shared_from_this()); return std::function<void()>(std::bind(

Passing a lambda is really easy in c++11: func( []( int arg ) { // code } ) ; But I'm wondering, what is the cost of passing a lambda to a function like this? What if func passes the lambda to other functions? void func( function< void (int arg) > f ) { doSomethingElse( f ) ; } Is the passing of the lambda expensive? Since a function object can be assigned 0, function< void (int arg) > f = 0 ; // 0 means "not init" it leads me to think that function objects kind of act like pointers. But without use of new , then it means they might be like value-typed struct or classes, which defaults to