Як вказати вказівник на перевантажену функцію?

Я хочу передати перевантажену функцію std::for_each()алгоритму. Наприклад,

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

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

Я очікую, що компілятор вирішить f()за типом ітератора. Мабуть, це (GCC 4.1.2) не робить цього. Отже, як я можу вказати, що f()я хочу?

Ви можете static_cast<>()вказати, яку fвикористовувати відповідно до підпису функції, що має на увазі тип вказівника функції:

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

Або ви також можете зробити це:

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

Якщо fце функція члена, то вам потрібно використовувати mem_funабо для вашого випадку використовувати рішення, представлене в цій статті доктора Добба .

Лямбди на допомогу! (зверніть увагу: C ++ 11 потрібно)

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

Або використовуючи decltype для параметра лямбда:

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

З поліморфними лямбдами (C ++ 14):

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

Або роз'єднати, видаливши перевантаження (працює лише для вільних функцій):

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

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

Чому це не працює

Я очікую, що компілятор вирішить f()за типом ітератора. Мабуть, це (gcc 4.1.2) не робить цього.

Було б чудово, якби це було так! Однак for_eachце шаблон функції, оголошений як:

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

Для виведення шаблону потрібно вибрати тип для UnaryFunctionв точці виклику. Але fне має конкретного типу - це перевантажена функція, їх багато fз різними типами. Не існує поточного способу for_eachсприяти процесу виведення шаблону, заявивши, що fвін хоче, тому виведення шаблону просто не вдається. Для того, щоб виведення шаблону вдалося, вам потрібно зробити більше роботи на сайті виклику.

Загальне рішення для його фіксації

Стрибки сюди через кілька років, а С ++ 14 пізніше. Замість того, щоб використовувати static_cast(що дозволило б вирахуванню шаблону досягти успіху за допомогою "виправлення", яке fми хочемо використовувати, але вимагає, щоб ви вручну зробили роздільну здатність перевантаження, щоб "виправити" правильну), ми хочемо змусити компілятор працювати для нас. Ми хочемо зателефонувати fна деякі аргументи. Найбільш загальним способом:

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

Це дуже багато, але ця проблема виникає прикро часто, тому ми можемо просто зафіксувати це в макросі (зітхання):

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

а потім просто скористайтеся ним:

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

Це зробить саме те, що ви хочете, щоб робив компілятор - виконайте роздільну здатність перевантаження над fсамою назвою і просто зробите правильно. Це працюватиме незалежно від того f, вільна функція чи функція члена.

Не відповідати на ваше запитання, але я єдиний, хто знаходить

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

і простішою, і коротшою, ніж for_eachальтернатива, запропонована в силіконі в цьому випадку?

Проблема тут, мабуть, не в роздільній здатності перевантаження, а фактично у виведенні параметра шаблону . Хоча відмінна відповідь від @ In silico вирішить неоднозначну проблему з перевантаженням загалом, найкраще виправлення при роботі std::for_each(або подібному) - це чітко вказати параметри шаблону :

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

Якщо ви не проти використовувати C ++ 11, ось розумний помічник, схожий на (але менш потворний, ніж) статичний ролик:

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

(Працює для функцій-членів; повинно бути очевидним, як змінити його для роботи на автономних функціях, і ви повинні мати можливість надати обидві версії, і компілятор вибере правильну для вас.)

Дякую Міро Кнейп за пропозицію: див. Також https://groups.google.com/a/isocpp.org/d/msg/std-discussion/rLVGeGUXsK0/IGj9dKmSyx4J .