如何指定指向重载函数的指针？

Question

我想将重载函数传递给 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() 呢？

Answer 1

您可以使用 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，或者根据您的情况，使用Dobb 博士的文章中介绍的解决方案< /a>.

Answer 2

兰姆达来救援！ （注意：需要 C++11）

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

或者使用 decltype 作为 lambda 参数：

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

使用多态 lambda (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);
}

Answer 3

为什么不起作用

我希望编译器通过迭代器类型解析f()。显然，它（gcc 4.1.2）没有这样做。

如果真是这样那就太好了！然而，for_each是一个函数模板，声明为：

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

模板推导需要在调用时为UnaryFunction选择一个类型。但 f 没有特定的类型 - 它是一个重载函数，有许多 f，每个都有不同的类型。 for_each 目前没有办法通过说明它想要哪个 f 来帮助模板推导过程，因此模板推导根本会失败。为了让模板推演成功，还需要在调用端做更多的工作。

修复它的通用解决方案

几年后跳到这里，C++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是自由函数还是成员函数，这都会起作用。

Answer 4

这里的问题似乎不是重载解析，而是模板参数推导。虽然 @In silico 的 优秀答案 一般会解决模糊的重载问题，但在处理 < 时，这似乎是最好的解决方法code>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" );
}

Answer 5

如果您不介意使用 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; }

适用于成员函数；应该很明显如何修改它以适用于独立函数，并且您应该能够提供这两个版本，编译器将为您选择正确的版本。）

感谢 Miro Knejp 的建议：另请参阅https://groups.google.com/a/isocpp.org/d/msg/std-discussion/ rLVGeGUXsK0/IGj9dKmSyx4J。

Answer 6

不是为了回答你的问题，但我是唯一一个发现

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

比计算机在这种情况下建议的 for_each 替代方案更简单和更短的人吗？