Wie gebe ich einen Zeiger auf eine überladene Funktion an?

Ich möchte eine überladene Funktion an den std::for_each()Algorithmus übergeben. Beispielsweise,

class A {
    void f(char c);
    void f(int i);

    void scan(const std::string& s) {
        std::for_each(s.begin(), s.end(), f);
    }
};

Ich würde erwarten, dass der Compiler nach f()dem Iteratortyp aufgelöst wird. Anscheinend macht es das (GCC 4.1.2) nicht. Wie kann ich also angeben, welche f()ich möchte?

Sie können static_cast<>()angeben, welche fgemäß der vom Funktionszeigertyp implizierten Funktionssignatur verwendet werden sollen:

// Uses the void f(char c); overload
std::for_each(s.begin(), s.end(), static_cast<void (*)(char)>(&f));
// Uses the void f(int i); overload
std::for_each(s.begin(), s.end(), static_cast<void (*)(int)>(&f)); 

Oder Sie können dies auch tun:

// The compiler will figure out which f to use according to
// the function pointer declaration.
void (*fpc)(char) = &f;
std::for_each(s.begin(), s.end(), fpc); // Uses the void f(char c); overload
void (*fpi)(int) = &f;
std::for_each(s.begin(), s.end(), fpi); // Uses the void f(int i); overload

Wenn fes sich um eine Mitgliedsfunktion handelt, müssen Sie die in diesem Artikel von Dr. Dobb vorgestellte Lösung verwenden mem_funoder für Ihren Fall verwenden .

Lambdas zur Rettung! (Hinweis: C ++ 11 erforderlich)

std::for_each(s.begin(), s.end(), [&](char a){ return f(a); });

Oder verwenden Sie decltype für den Lambda-Parameter:

std::for_each(s.begin(), s.end(), [&](decltype(*s.begin()) a){ return f(a); });

Mit polymorphen Lambdas (C ++ 14):

std::for_each(s.begin(), s.end(), [&](auto a){ return f(a); });

Oder durch Entfernen der Überladung eindeutig (funktioniert nur für freie Funktionen):

void f_c(char i)
{
    return f(i);
}

void scan(const std::string& s)
{
    std::for_each(s.begin(), s.end(), f_c);
}

Warum funktioniert es nicht?

Ich würde erwarten, dass der Compiler nach f()dem Iteratortyp aufgelöst wird. Anscheinend macht es (gcc 4.1.2) es nicht.

Es wäre großartig, wenn das der Fall wäre! Es handelt sich jedoch for_eachum eine Funktionsvorlage, die wie folgt deklariert ist:

template <class InputIterator, class UnaryFunction>
UnaryFunction for_each(InputIterator, InputIterator, UnaryFunction );

Der Vorlagenabzug muss zum UnaryFunctionZeitpunkt des Aufrufs einen Typ auswählen . Hat faber keinen bestimmten Typ - es ist eine überladene Funktion, es gibt viele fs mit jeweils unterschiedlichen Typen. Es gibt derzeit keine Möglichkeit for_each, den Prozess des Vorlagenabzugs zu unterstützen, indem angegeben wird, was fgewünscht wird. Daher schlägt der Vorlagenabzug einfach fehl. Damit der Vorlagenabzug erfolgreich ist, müssen Sie mehr Arbeit auf der Anrufseite leisten.

Generische Lösung zur Behebung

Ein paar Jahre hier und später C ++ 14. Anstatt eine zu verwenden static_cast(die den Abzug von Vorlagen durch "Fixieren" erfolgreich machen würde, was fwir verwenden möchten, aber Sie müssen die Überladungsauflösung manuell durchführen, um die richtige zu "reparieren"), möchten wir, dass der Compiler für uns funktioniert. Wir wollen feinige Argumente anrufen . Auf die allgemeinste Art und Weise ist das:

[&](auto&&... args) -> decltype(auto) { return f(std::forward<decltype(args)>(args)...); }

Das ist eine Menge zu tippen, aber diese Art von Problem tritt ärgerlich häufig auf, so dass wir das einfach in ein Makro einwickeln können (Seufzer):

#define AS_LAMBDA(func) [&](auto&&... args) -> decltype(func(std::forward<decltype(args)>(args)...)) { return func(std::forward<decltype(args)>(args)...); }

und dann benutze es einfach:

void scan(const std::string& s) {
    std::for_each(s.begin(), s.end(), AS_LAMBDA(f));
}

Dies macht genau das, was Sie sich vom Compiler gewünscht haben - führen Sie eine Überladungsauflösung für den Namen fselbst durch und tun Sie einfach das Richtige. Dies funktioniert unabhängig davon, ob fes sich um eine freie Funktion oder eine Mitgliedsfunktion handelt.

Nicht um deine Frage zu beantworten, aber bin ich der einzige, der findet

for ( int i = 0; i < s.size(); i++ ) {
   f( s[i] );
}

sowohl einfacher als auch kürzer als die for_eachvon in silico in diesem Fall vorgeschlagene Alternative?

Das Problem hier scheint nicht die Überlastungsauflösung zu sein, sondern die Ableitung von Vorlagenparametern . Während die hervorragende Antwort von @In silico ein mehrdeutiges Überlastungsproblem im Allgemeinen löst, scheint es die beste Lösung zu sein, wenn std::for_each(oder ähnliches) die Vorlagenparameter explizit angegeben werden :

// Simplified to use free functions instead of class members.

#include <algorithm>
#include <iostream>
#include <string>

void f( char c )
{
  std::cout << c << std::endl;
}

void f( int i )
{
  std::cout << i << std::endl;
}

void scan( std::string const& s )
{
  // The problem:
  //   error C2914: 'std::for_each' : cannot deduce template argument as function argument is ambiguous
  // std::for_each( s.begin(), s.end(), f );

  // Excellent solution from @In silico (see other answer):
  //   Declare a pointer of the desired type; overload resolution occurs at time of assignment
  void (*fpc)(char) = f;
  std::for_each( s.begin(), s.end(), fpc );
  void (*fpi)(int)  = f;
  std::for_each( s.begin(), s.end(), fpi );

  // Explicit specification (first attempt):
  //   Specify template parameters to std::for_each
  std::for_each< std::string::const_iterator, void(*)(char) >( s.begin(), s.end(), f );
  std::for_each< std::string::const_iterator, void(*)(int)  >( s.begin(), s.end(), f );

  // Explicit specification (improved):
  //   Let the first template parameter be derived; specify only the function type
  std::for_each< decltype( s.begin() ), void(*)(char) >( s.begin(), s.end(), f );
  std::for_each< decltype( s.begin() ), void(*)(int)  >( s.begin(), s.end(), f );
}

void main()
{
  scan( "Test" );
}

Wenn es Ihnen nichts ausmacht, C ++ 11 zu verwenden, finden Sie hier einen cleveren Helfer, der dem statischen Cast ähnlich (aber weniger hässlich als dieser) ist:

template<class... Args, class T, class R>
auto resolve(R (T::*m)(Args...)) -> decltype(m)
{ return m; }

template<class T, class R>
auto resolve(R (T::*m)(void)) -> decltype(m)
{ return m; }

(Funktioniert für Elementfunktionen; es sollte offensichtlich sein, wie es für freistehende Funktionen geändert werden kann, und Sie sollten in der Lage sein, beide Versionen bereitzustellen, und der Compiler wählt die richtige für Sie aus.)

Vielen Dank an Miro Knejp für den Vorschlag: siehe auch https://groups.google.com/a/isocpp.org/d/msg/std-discussion/rLVGeGUXsK0/IGj9dKmSyx4J .