ich versuche gerade folgendes, aber der Compiler akzeptiert das nicht:
Ich habe folgendes http://de.cppreference.com/w/cpp/utility/functional/function Beispiel verwendet (// store a call to a member function):

std::function<std::string::size_type(const std::string&, const ::std::string&)>my_func = &std::string::find;

Ich bekomme folgende Fehlermeldung:

Error	3	error C2440: 'initializing' : cannot convert from 'overloaded-function' to 'std::function<unsigned int (const std::string &,const std::string &)>'

Was mache ich falsch?

Benutze std::bind(..)

Edit:
...gar nicht so einfach, habe versucht ein Bsp. zu machen... ich würde dir empfehlen zuerst ein einfacheres Bsp. zu nehmen... auch ist der Praxisbezug fraglich... da würde man vermutlich gleich eine Lambda übergeben.

void f() {
  using namespace std;
  using size_type = string::size_type;
  function<size_type(const string&, const string&, size_type)> my_func =
    static_cast<size_type(string::*)(const string&, size_type)const>(&string::find);
  ...
}

ächz

ungefähr

template <typename R, typename... Args>
auto make_function(R(*f)(Args...)) { return std::function<R(Args...)>(f); }
template <typename R, typename C, typename... Args>
auto make_function(R(C::*f)(Args...)) { return std::function<R(C&, Args...)>(f); }
template <typename R, typename C, typename... Args>
auto make_function(R(C::*f)(Args...)const) { return std::function<R(const C&, Args...)>(f); }
template <typename R, typename C, typename... Args>
auto make_function(R(C::*f)(Args...)volatile) { return std::function<R(volatile C&, Args...)>(f); }
template <typename R, typename C, typename... Args>
auto make_function(R(C::*f)(Args...)const volatile) { return std::function<R(const volatile C&, Args...)>(f); }

und dann

void f() {
  using namespace std;
  using size_type = string::size_type;
  auto my_func = make_function(static_cast<size_type(string::*)(const string&, size_type)const>(&string::find));
  ...
}

#define REM_CTOR(...) __VA_ARGS__

template <typename T, typename R>
using helper_ = std::conditional_t<std::is_rvalue_reference<R>{}, T&&, T&>;

#define SPEC(var, cv, ref) \
template <typename R, typename C, typename... Args> \
struct get_std_function<R(C::*)(Args... REM_CTOR var) cv ref > \
{using type = std::function<R(helper_<C cv, int ref>, Args... REM_CTOR var)>;};

#define REF(var, cv) SPEC(var, cv,) SPEC(var, cv, &) SPEC(var, cv, &&)

#define CV(var) REF(var,) REF(var, const) \
                REF(var, volatile) REF(var, const volatile)

template <typename> struct get_std_function;

CV(()) CV((,...))

Demo.

( make_function reduziert sich dann auf

template <typename T>
auto make_function(T t) { return get_std_function<T>::type(f); }

)

PS: Wo SO schon verlinkt ist: Wer bist du dort? Ich kann es leider nicht erschließen. Ich vermute derjenige der oben die Frage gestellt hat (T.C.), oder hvd.