Comment spécifier un pointeur vers une fonction surchargée?

Je souhaite transmettre une fonction surchargée à l' std::for_each()algorithme. Par exemple,

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

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

Je m'attendrais à ce que le compilateur résolve f()par le type d'itérateur. Apparemment, cela (GCC 4.1.2) ne le fait pas. Alors, comment puis-je spécifier ce que f()je veux?

Vous pouvez utiliser static_cast<>()pour spécifier lequel futiliser en fonction de la signature de fonction impliquée par le type de pointeur de fonction:

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

Ou, vous pouvez également faire ceci:

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

S'il fs'agit d'une fonction membre, vous devez utiliser mem_fun, ou pour votre cas, utiliser la solution présentée dans cet article de Dr. Dobb .

Lambdas à la rescousse! (Remarque: C ++ 11 requis)

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

Ou en utilisant decltype pour le paramètre lambda:

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

Avec des lambdas polymorphes (C ++ 14):

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

Ou dissipez l'ambiguïté en supprimant la surcharge (ne fonctionne que pour les fonctions gratuites):

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

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

Pourquoi ça ne marche pas

Je m'attendrais à ce que le compilateur résolve f()par le type d'itérateur. Apparemment, cela (gcc 4.1.2) ne le fait pas.

Ce serait génial si c'était le cas! Cependant, for_eachest un modèle de fonction, déclaré comme:

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

La déduction de modèle doit sélectionner un type pour UnaryFunctionau moment de l'appel. Mais fn'a pas de type spécifique - c'est une fonction surchargée, il y en a beaucoup favec chacun des types différents. Il n'existe actuellement aucun moyen pour for_eachfaciliter le processus de déduction du modèle en indiquant ce fqu'il veut, donc la déduction du modèle échoue tout simplement. Pour que la déduction du modèle réussisse, vous devez travailler davantage sur le site d'appel.

Solution générique pour le réparer

Sauter ici quelques années et C ++ 14 plus tard. Plutôt que d'utiliser un static_cast(qui permettrait à la déduction de modèle de réussir en "corrigeant" ce que fnous voulons utiliser, mais vous oblige à faire manuellement une résolution de surcharge pour "corriger" la bonne), nous voulons que le compilateur fonctionne pour nous. Nous voulons faire appel fà certains arguments. De la manière la plus générique possible, c'est:

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

C'est beaucoup à taper, mais ce genre de problème survient fréquemment, nous pouvons donc simplement l'envelopper dans une macro (soupir):

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

puis utilisez-le simplement:

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

Cela fera exactement ce que vous souhaitez que le compilateur fasse - effectuer une résolution de surcharge sur le nom flui-même et faire ce qu'il faut. Cela fonctionnera indépendamment du fait qu'il s'agisse d' fune fonction libre ou d'une fonction membre.

Pas pour répondre à ta question, mais suis-je le seul à trouver

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

à la fois plus simple et plus court que l' for_eachalternative proposée par in silico dans ce cas?

Le problème ici ne semble pas être la résolution de surcharge, mais en fait la déduction des paramètres de modèle . Alors que l' excellente réponse de @In silico résoudra un problème de surcharge ambigu en général, il semble que la meilleure solution lorsqu'il s'agit de std::for_each(ou similaire) est de spécifier explicitement ses paramètres de modèle :

// 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 cela ne vous dérange pas d'utiliser C ++ 11, voici une aide intelligente qui est similaire (mais moins moche que) à la distribution statique:

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

(Fonctionne pour les fonctions membres; devrait être évident comment le modifier pour qu'il fonctionne pour les fonctions autonomes, et vous devriez être en mesure de fournir les deux versions et le compilateur sélectionnera la bonne pour vous.)

Merci à Miro Knejp d'avoir suggéré: voir aussi https://groups.google.com/a/isocpp.org/d/msg/std-discussion/rLVGeGUXsK0/IGj9dKmSyx4J .