2

我可以使用函数指针作为模板参数，如下所示

template<class R, class T, R (*Fun)(T)>
class MyClass;

任何让它变得容易的方法

MyClass<&MyFun> a;
4

3 回答 3

1

这是一个可怕的答案，但我想不出更好的答案。

template<typename R, typename Arg, R(*Fun)(Arg)>
class MyClass {};

template<typename R, typename Arg>
struct MyClassHelper {
  template<R(*Fun)(Arg)>
  struct Class {
    typedef MyClass<R, Arg, Fun> type;
  };
};

template<typename R, typename Arg>
MyClassHelper<R, Arg> GetMyClass(R(*Fun)(Arg)); // no impl

void MyFun(int) {}

int main() {
  typedef decltype( GetMyClass(&MyFun) ) A;
  typedef A::Class<&MyFun> B;
  typedef B::type a;
  // or, in one line:
  decltype( GetMyClass(&MyFun) )::Class<&MyFun>::type b;
}

这是丑陋的罪恶。但至少它提取了参数类型MyFun而不重复它们......

于 2013-01-01T19:22:41.637 回答
0

不可能完全像问题中那样，但是如果您稍微调整一下设计，这是可能的。举个例子：
假设你有以下功能：

int foo (int i) { return i; }

现在你想写：

MyClass<&foo> a; // instead of `Myclass<int, int, &foo> a;

在这里你将如何实现它。首先改变简单的功能：

int foo (int i) { return i; }

封装函数对象：

struct foo { // <--- function name here
  int operator () (int i) { return i; } // <--- function body here
};

两者几乎相同（在函数对象的情况下，传递了一个额外的this指针，这在自由函数的情况下不会发生）：

int x = foo(2); // 1st case
int x = foo_(2); // 2nd case where `foo_` is an object of `struct foo`

现在您可以随心所欲地使用！

template<class Func>
class MyClass {...}
MyClass<foo> a;

这是一个工作演示。

于 2013-01-01T19:38:56.613 回答
-1

已经有了std::ptr_fun。使用 C++11，您可以将其用作

auto a = std::ptr_fun(&MyFun);

更新：

正如其他尝试和非尝试 BTW 所表明的那样，您的模板是否不可能，至少“像”一样简单;-)。但是，如果您的主要目标是“尽可能简单”，您可以做的是重新实现现有的标准模板函数模式（std::ptr_fun等）以返回所需的类型。std::make_pair

于 2013-01-01T17:38:10.593 回答