std::function und std::string::find

Hallo,

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?

theta

1. Es gibt keine std::string::find(..) Funktion mit der Signatur std::string::size_type(const std::string&, const ::std::string&)
2. std::string::find(..) ist eine Instanz-Funktion, d.h. sie muss mit einem Objekt aufgerufen werden.

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.

Leider musst Du genau sagen, welche Überladung von string::find() Du haben willst. Also den Pointer casten.
Und den dritten Paramter von string::find() nicht vergessen!

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

camper

Komisch eigentlich, dass es kein make_function gibt. Dann könnte man sich das doppelte Ausschreiben des Typs sparen.

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));
  ...
}

Columbo

@camper: Da muss noch ein wenig mehr berücksichtigt werden. Ich habe ein Makro dafür hier vorgegeben. Wenn wir das ein wenig umschreiben, bekommen wir's:

#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.