Generate functor with shared_from_this - c++

Question

I'd like to create a functor from a class A that inherits from enable_shared_from_this, that is for a class like this:
class A: public std::enable_shared_from_this<A> {
...
}
I want to have a member function that looks something like this (incorrect code):
template <typename Args...>
std::function<void(Args ...)> functor_from_this(void (A::*method)(Args...)) {
return std::bind(method, shared_from_this());
}
The code above generates several errors, starting with warning C4180: qualifier applied to function type has no meaning; ignored, which makes me suspect I'm going about this the wrong way. How do I go about achieving something like this?
Extra credits for (a) binding the Args... to the functor as well so I get a function whose signature is void fn(), and (b) doing all this in a general-purpose class that inherits from enable_shared_from_this<T>.

Answer 1

Well, for C++14 the solution is easy enough to write. Just forgo std::bind and return a lambda instead:
#include <memory>
#include <iostream>
#include <functional>
struct A: std::enable_shared_from_this<A> {
template <typename... Args>
std::function<void(Args...)> functor_from_this(void (A::*method)(Args...)) {
return [=, obj = shared_from_this()](Args... args) {
((*obj).*method)(args...);
};
}
void foo(int) { std::cout << "foo" << '\n'; }
void bar() { std::cout << "bar" << '\n'; }
};
int main()
{
auto a = std::make_shared<A>();
auto f = a->functor_from_this(&A::foo);
auto b = a->functor_from_this(&A::bar);
f(1);
b();
}
For C++11 as Jarod42 pointed out in a comment, use a much simpler intermediate variable:
#include <memory>
#include <iostream>
#include <functional>
struct A: std::enable_shared_from_this<A> {
template <typename... Args>
std::function<void(Args...)> functor_from_this(void (A::*method)(Args...)) {
auto obj = shared_from_this();
return [=](Args... args) {
((*obj).*method)(args...);
};
}
void foo(int) { std::cout << "foo" << '\n'; }
void bar() { std::cout << "bar" << '\n'; }
};
int main()
{
auto a = std::make_shared<A>();
auto f = a->functor_from_this(&A::foo);
auto b = a->functor_from_this(&A::bar);
f(1);
b();
}

Answer 2

For extra credit (B), here is the solution I found, based on the answer by StoryTeller & Jarod:
#include <memory>
#include <iostream>
#include <functional>
template <class T>
class enable_functor_from_this: public std::enable_shared_from_this<T> {
public:
template <typename... Args>
decltype(auto) functor_from_this(void (T::*method)(Args...)) {
auto obj = this->shared_from_this();
return [=](Args... args) {
((*obj).*method)(args...);
};
}
};
struct A: enable_functor_from_this<A> {
void foo(int) { std::cout << "foo" << '\n'; }
void bar() { std::cout << "bar" << '\n'; }
};
int main()
{
auto a = std::make_shared<A>();
auto f = a->functor_from_this(&A::foo);
auto b = a->functor_from_this(&A::bar);
f(1);
b();
}