¿Cómo especifico un puntero a una función sobrecargada?

Quiero pasar una función sobrecargada al std::for_each()algoritmo. Por ejemplo,

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

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

Esperaría que el compilador se resuelva f()por el tipo de iterador. Aparentemente, (GCC 4.1.2) no lo hace. Entonces, ¿cómo puedo especificar cuál f()quiero?

Puede usar static_cast<>()para especificar cuál fusar de acuerdo con la firma de función implícita en el tipo de puntero de función:

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

O también puedes hacer esto:

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

Si fes una función miembro, entonces debe usar mem_fun, o para su caso, usar la solución presentada en este artículo del Dr. Dobb .

Lambdas al rescate! (nota: se requiere C ++ 11)

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

O usando decltype para el parámetro lambda:

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

Con lambdas polimórficas (C ++ 14):

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

O desambiguate eliminando la sobrecarga (solo funciona para funciones gratuitas):

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

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

¿Por qué no funciona?

Esperaría que el compilador se resuelva f()por el tipo de iterador. Aparentemente, (gcc 4.1.2) no lo hace.

¡Sería genial si ese fuera el caso! Sin embargo, for_eaches una plantilla de función, declarada como:

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

La deducción de plantilla debe seleccionar un tipo UnaryFunctionen el punto de la llamada. Pero fno tiene un tipo específico: es una función sobrecargada, hay muchos fs cada uno con diferentes tipos. No hay una forma actual de for_eachayudar al proceso de deducción de plantillas al indicar cuál fquiere, por lo que la deducción de plantillas simplemente falla. Para que la deducción de la plantilla sea exitosa, debe trabajar más en el sitio de la llamada.

Solución genérica para arreglarlo

Saltando aquí unos años y C ++ 14 más tarde. En lugar de usar un static_cast(que permitiría que la deducción de plantillas tenga éxito al "arreglar" lo fque queremos usar, pero requiere que usted haga manualmente la resolución de sobrecarga para "arreglar" la correcta), queremos que el compilador funcione para nosotros. Queremos recurrir fa algunos argumentos. De la manera más genérica posible, eso es:

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

Eso es mucho para escribir, pero este tipo de problema surge de manera molesta con frecuencia, por lo que podemos envolverlo en una macro (suspiro):

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

y luego solo utilízalo:

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

Esto hará exactamente lo que desearía que hiciera el compilador: realizar una resolución de sobrecarga en el nombre fmismo y simplemente hacer lo correcto. Esto funcionará independientemente de si fes una función libre o una función miembro.

No para responder a tu pregunta, pero ¿soy el único que encuentra

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

tanto más simple como más corto que la for_eachalternativa sugerida por in silico en este caso?

El problema aquí parece no ser la resolución de sobrecarga sino la deducción de parámetros de plantilla . Si bien la excelente respuesta de @In silico resolverá un problema de sobrecarga ambiguo en general, parece que la mejor solución cuando se trata std::for_each(o similar) es especificar explícitamente sus parámetros de plantilla :

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

Si no te importa usar C ++ 11, aquí hay un ayudante inteligente que es similar (pero menos feo que) al reparto estático:

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

(Funciona para funciones miembro; debe ser obvio cómo modificarlo para que funcione para funciones independientes, y debe poder proporcionar ambas versiones y el compilador seleccionará la correcta para usted).

Gracias a Miro Knejp por sugerir: ver también https://groups.google.com/a/isocpp.org/d/msg/std-discussion/rLVGeGUXsK0/IGj9dKmSyx4J .