4

如何获得指向编译器在检查参数后会选择的重载函数的函数指针？在这个例子中：

#include <iostream>

void MyFunction(float a){}
void MyFunction(int a){}

int main()
{
  float a;

  MyFunction(a);

  void (*manualFunctionPointer)(float);
  manualFunctionPointer(a);

  // automaticFunctionPointer = ?
}

我已经指定我想要一个指向接受浮点数并返回 void 的函数的函数指针。编译器当然可以自己解决这个问题，因为 MyFunction(a) 调用调用了正确的函数。有没有办法获得指向编译器选择的函数的函数指针？

4

3 回答 3

2 
#include <iostream>

void MyFunction(float a){std::cout << "float\n";}
void MyFunction(int a){std::cout << "int\n";}

template<typename Func, typename T>
void Do( Func f, T t )
{
    f(t);
}
template<typename T>
void DoMyFunction( T t )
{
  Do(static_cast<void(*)(T)>(MyFunction), t);
}
template<typename T>
void DoSomeFunction( T t, void(*func)(T) )
{
  Do(func, t);
}
int main()
{
  float a;

  MyFunction(a);

  void (*manualFunctionPointer)(float) = MyFunction;
  manualFunctionPointer(a);

//  Do(MyFunction, a); -- does not compile
  Do(static_cast<void(*)(float)>(MyFunction), a);
  DoMyFunction(a);
  DoSomeFunction(a, MyFunction);
}

以上工作。我以 4 种不同的方式选择了 MyFunction。

如果您愿意做一些样板，并且想要解决“如果 a 是一个char”问题，那么这可能会有所帮助：

// wrap the idea of calling MyFunction in a type:
struct MyFunctionFunctor {
  template<typename T> static auto Do( T&& t )->decltype(MyFunction(std::forward(t))) {
    return MyFunction(std::forward(t));
  }
};
// Calling MyFunctionFunctor::Do( x ) will basically do static dispatch on all of
// the overloads of MyFunction

// wrap the idea of dispatching a variable to a functor:
template<typename T, typename Functor>
struct Dispatch {
  static auto Do( T t )->decltype( Functor::Do( t ) )
  {
    return Functor::Do( t );
  }
}

int main()
{
  char a;
  auto func_ptr = &Dispatch<decltype(a), MyFunctionFunctor>::Do;
  func_ptr(a);
}

但是，如前所述，这需要我们将其包装MyFunction起来，以便用类型来描述它。我不知道没有样板文件的方法。

于 2012-11-29T18:59:31.213 回答
1

编辑：这不是真正的解决方案；这更像是一个骗局。但我认为它可以满足需要。

#define INVOKE(hof, func, arg) \
   hof([](const decltype(arg)& arg_){return func(arg_);}, arg)

例子：

// This function mimics the signature of QtCollector::run for testing
template <typename Functor, typename Arg1>
auto QtConcurrent_run(Functor functor, const Arg1 &arg1)
      -> decltype(functor(arg1))
{
      return functor(arg1);
}

#include <iostream>

int f(int x) { std::cout << "int" << " " << x << std::endl; return x; }
double f(double x) { std::cout << "double" << " " << x << std::endl; return x; }

int main() {
  INVOKE(QtConcurrent_run, f, 3);
  INVOKE(QtConcurrent_run, f, 3.14);
  INVOKE(QtConcurrent_run, f, '3');
  return 0;
}

在ideone上看到它。

出于历史目的和一些解释，原始答案如下。

只是为了清楚起见，因为这是一个有趣的问题，但也许让您的项目移动对您来说更重要，您是否有理由不想将各种函数覆盖包装到函子结构中，并传递函子struct 直接到 QtConcurrent::run ，哪个会欣然接受这样的事情？

如果函数的所有定义都在一个类中，那么就没有问题：

struct f_collector {
  ReturnType1 f(ArgType1 arg);
  ReturnType2 f(ArgType2 arg);
  ReturnType3 f(ArgType3 arg);
  // ...
  // Make it a functor:
  template<typename Argtype>
  auto operator()(const Argtype& arg) -> decltype(f(arg)) { return f(arg); }
}

然后你可以打电话QtConcurrent::run(f_collector(), argument)，它会正常工作（除非你需要完美的转发，但这是一个小细节）。

所以我有了以下想法，即动态构建一个像上面这样的函子，这基本上意味着给它一个 lambda 表达式。lambda 本身就是很简单的样板；很容易从中制作宏：

// This is the functor
template<typename Arg, typename Func> struct wrapper {
  wrapper(Func f) : f(f) {}
  const Func f;
  auto operator()(Arg arg) const -> decltype(f(arg)) {return f(arg);}
};

// As usual, a make_* function, because you can't template deduce a constructor
template<typename Arg, typename Func>
wrapper<Arg, Func> make_wrapper(Func f) {
  return wrapper<Arg, Func>(f);
}

// Boilerplate inside a macro
#define INVOKE(hof,func,arg) \
   hof(make_wrapper<decltype(arg)>( [](const decltype(arg)& arg_) { \
                                      return func(arg_); \
                                    }), \
       arg) 

// The above was ugly, but it's easy to use. For testing, I define
// this with a similar signature to QtConcurrent::run
template <typename Functor, typename Arg1>
auto QtConcurrent_run(Functor functor, const Arg1 &arg1)
      -> decltype(functor(arg1))
{
      return functor(arg1);
}

#include <iostream>

int f(int x) { std::cout << "int" << " " << x << std::endl; return x; }
double f(double x) { std::cout << "double" << " " << x << std::endl; return x; }


int main() {
  INVOKE(QtConcurrent_run, f, 3);
  INVOKE(QtConcurrent_run, f, 3.14);
  INVOKE(QtConcurrent_run, f, '3');
  return 0;
}

但是后来我想起了 lambda 以及它们的其他优点，只要它们没有捕获，就可以自动转换为函数指针。而且这个 lambda 没有捕获，因为唯一的外部符号是函数本身，而不是具有自动存储类的对象。所以，我认为底线是，你实际上可以用一些样板来做到这一点：

#define INVOKE(hof, func, arg) \
   hof([](const decltype(arg)& arg_){return func(arg_);}, arg);
于 2012-11-30T00:37:15.463 回答
0

更换浮子

void (*manualFunctionPointer)(float);

和

void (*manualFunctionPointer)(decltype(a));

然后无论发生什么变化，manualFunctionPointer 都会随之而来

于 2012-11-29T19:01:17.627 回答