stdbind

I have two overloads of a function foo which take different std::function s which results in an ambiguity issue for the latter when used with the result of a std::bind . I don't understand why only this is ambiguous. void foo(std::function<void(int)>) {} void foo(std::function<int()>) {} void take_int(int) { } int ret_int() { return 0; } When using int() with a bind function I get an ambiguity error foo(std::bind(ret_int)); // ERROR With the gcc-5.1 error (and similar with clang) error: call to 'foo' is ambiguous foo(std::bind(ret_int)); ^~~ note: candidate function void foo(std::function<void

Let's say this is a C function to be wrapped: void foo(int(__stdcall *callback)()); The two main pitfalls with C function pointer callbacks are: Not being able to store bind expressions Not being able to store capturing lambdas I would like to know the best way to wrap functions like these to do so. The first is particularly useful for a member function callback, and the second for an inline definition that uses surrounding variables, but those are not the only uses. The other property of these particular function pointers is that they need to use the __stdcall calling convention. This, to my

I have the following code: #include <stdio.h> #include <functional> template <typename T> auto callback(T&& func) ->decltype(func()) { return func(); } double test(double& value) { value=value+1.0; return value; } int main(void) { double t=1.0; printf("%f\n",t); test(t); printf("%f\n",t); callback(std::bind(test,t)); printf("%f\n",t); } And it outputs 1.000000 2.000000 2.000000 Which implies the callback function got a copy of t instead of a reference to t . I am wondering what happened, since for std::bind it should be perfect-forwarding. std::bind uses value semantics by default. It's a sane

I want to implement a manager that stores callbacks to member functions of polymorphic classes using C++11. The issue is that I am not sure how to handle the case where the object that the member belongs to gets deleted or should be deleted and I want to make the interface as simple as possible. So I thought of the following: Store a std::weak_ptr to the object as well as a std::function to the member. The following seems to work: class MyBase { public: MyBase() {} virtual ~MyBase() {} }; //-------------------------------------------------- class MyClass : public MyBase { public: MyClass() :

I cannot find out how to bind a parameter to an overloaded function using std::bind . Somehow std::bind cannot deduce the overloaded type (for its template parameters). If I do not overload the function everything works. Code below: #include <iostream> #include <functional> #include <cmath> using namespace std; using namespace std::placeholders; double f(double x) { return x; } // std::bind works if this overloaded is commented out float f(float x) { return x; } // want to bind to `f(2)`, for the double(double) version int main() { // none of the lines below compile: // auto f_binder = std: