Come posso specificare un puntatore a una funzione sovraccaricata?

Voglio passare una funzione sovraccarica std::for_each()all'algoritmo. Per esempio,

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

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

Mi aspetto che il compilatore si risolva in f()base al tipo di iteratore. Apparentemente (GCC 4.1.2) non lo fa. Quindi, come posso specificare quale f()voglio?

È possibile utilizzare static_cast<>()per specificare quale futilizzare in base alla firma della funzione implicita nel tipo di puntatore a funzione:

// 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)); 

Oppure puoi anche fare questo:

// 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

Se fè una funzione membro, è necessario utilizzare mem_fun, o per il proprio caso, utilizzare la soluzione presentata in questo articolo del Dr. Dobb .

Lambdas in soccorso! (nota: C ++ 11 richiesto)

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

O usando decltype per il parametro lambda:

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

Con lambda polimorfi (C ++ 14):

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

O disambiguare rimuovendo il sovraccarico (funziona solo con funzioni gratuite):

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

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

Perché non funziona?

Mi aspetto che il compilatore si risolva in f()base al tipo di iteratore. Apparentemente, (gcc 4.1.2) non lo fa.

Sarebbe bello se fosse così! Tuttavia, for_eachè un modello di funzione, dichiarato come:

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

La detrazione del modello deve selezionare un tipo per UnaryFunctionnel punto della chiamata. Ma fnon ha un tipo specifico - è una funzione sovraccarica, ce ne sono molti fciascuno con tipi diversi. Non esiste un modo attuale per for_eachaiutare il processo di detrazione del modello dichiarando ciò fche desidera, quindi la detrazione del modello semplicemente fallisce. Affinché la deduzione del modello abbia esito positivo, è necessario svolgere più lavoro sul sito di chiamata.

Soluzione generica per risolverlo

Saltando qui qualche anno e C ++ 14 più tardi. Invece di usare un static_cast(che consentirebbe alla deduzione del modello di avere successo "riparando" che fvogliamo usare, ma richiede che tu faccia manualmente la risoluzione del sovraccarico per "riparare" quella corretta), vogliamo far funzionare il compilatore per noi. Vogliamo chiamare falcuni argomenti. Nel modo più generico possibile, questo è:

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

È molto da scrivere, ma questo tipo di problema si presenta fastidiosamente frequentemente, quindi possiamo semplicemente avvolgerlo in una macro (sospiro):

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

e poi basta usarlo:

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

Questo farà esattamente quello che vorresti fosse fatto dal compilatore: esegui la risoluzione del sovraccarico sul nome fstesso e fai semplicemente la cosa giusta. fFunzionerà indipendentemente dal fatto che sia una funzione libera o una funzione membro.

Non per rispondere alla tua domanda, ma sono l'unico che trova

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

sia più semplice che più breve for_eachdell'alternativa suggerita da in silico in questo caso?

Il problema qui sembra non essere la risoluzione del sovraccarico ma la deduzione dei parametri del modello . Mentre l' eccellente risposta di @In silico risolverà un ambiguo problema di sovraccarico in generale, sembra che la soluzione migliore quando si ha a che fare con std::for_each(o simili) sia specificare esplicitamente i parametri del modello :

// 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" );
}

Se non ti dispiace usare C ++ 11, ecco un aiuto intelligente che è simile (ma meno brutto) al cast statico:

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

(Funziona per le funzioni membro; dovrebbe essere ovvio come modificarlo per funzionare per le funzioni indipendenti e dovresti essere in grado di fornire entrambe le versioni e il compilatore selezionerà quello giusto per te.)

Grazie a Miro Knejp per avermi suggerito: vedi anche https://groups.google.com/a/isocpp.org/d/msg/std-discussion/rLVGeGUXsK0/IGj9dKmSyx4J .