3

我正在尝试编写一个以三件事为模板的函数：

  1. 第一种。
  2. 第二种。
  3. 具有参数 First 和 Second 类型的函数。

代码如下所示：

#include <iostream>
#include <typeinfo>
using namespace std;

// Assume that this function is in a library.  Can't be modified.
void bar(int x, int y) {
  cout << x << endl;
  cout << y << endl;
}

// My code is below:
template <typename Type1, typename Type2, void (*fn)(Type1, Type2)>
void foo(Type1 x1, Type2 x2) {
  fn(x1,x2);
}

int main() {
  foo<int, int, &bar>(1,2);
}

该代码有效，但我对我的模板必须包含<int, int, &bar>. 我希望编译器能弄清楚 bar 有int, int作为参数并弄清楚。

我尝试首先列出函数，然后列出类型，但在声明Type1中，函数原型中无法识别，因为它稍后在同一原型中定义。

有没有优雅的解决方案？

编辑：我绝对不想bar在堆栈上传递一个指针。我想在bar. 参数应该是 just (1, 2)。

Edit2：我的意思是我想写foo<&bar>(1,2).

4

2 回答 2

3

这是我不将函数作为参数传递的解决方案：

void bar(int a, int b) {
  cout <<  a << " " << b << endl;
}

template <class F, F *fn>
struct Foo {

  template <class... Args>
  static decltype(auto) foo(Args &&... args) {
    return fn(std::forward<Args>(args)...);
  }
};

int main() {

  Foo<decltype(bar), bar>::foo(1, 2);

  return 0;
}

正如你所看到的，你必须写bar两次，一次是为了它的类型，一次是为了它的价值，但我认为这是一个小小的不便。

或者简单的版本（如果你不能使用 c++11）

template <class F, F* fn>
struct Foo {

  template <class T1, class T2>
  static void foo(T1 t1, T2 t2) {
    fn(t1, t2);
  }
};

对于那些不介意将函数 obj 作为参数传递的人：

选项1：

template <class T1, class T2>
void foo(T1 x1, T2 x2, void (*fn)(T1, T2)) {
  fn(x1, x2);
}

foo(1, 2, bar);

选项 2：

template <class T1, class T2, class F = void(*)(T1, T2)>
void foo(T1 x1, T2 x2, F fn)) {
  fn(x1, x2);
}

foo(1, 2, bar);

选项 3：

template <class T1, class T2, class F>
void foo(T1 x1, T2 x2, F fn)) {
  fn(x1, x2);
}

foo(1, 2, bar);

选项 3b（真正的交易）：

template <class T1, class T2, class F>
void foo(T1 &&x1, T2 &&x2, F &&fn)) {
  std::forward<F>(fn)(std::forward(x1), std::forward(x2));
}

foo(1, 2, bar);

选项4（真正的交易）（嗯..取决于你需要什么）

template <class F, class... Args>
decltype(auto) foo(F &&fn, Args &&... args) {
  return std::forward<F>(fn)(std::forward<Args>(args)...);
}
于 2015-01-29T12:00:51.023 回答
0

您甚至可以避免使用包含该值bar的临时值键入两次。struct该结构将由任何体面的编译器进行优化，并且bar不会在堆栈上传递，尽管作为参数传递给foo:

template <typename Fn>
struct FooT {
  Fn &fn;
  FooT(Fn fn):fn(fn){}
  operator Fn *() {return fn;}
};

template <typename Fn>
inline FooT<Fn> foo(Fn *fn) {return FooT<Fn>(fn);}


int main() {
  foo(bar)(1,2);
}

注意：转换为Fn *允许fn直接调用，无需任何参数转发。如果需要，也可以使用模板operator ()传递/转发参数来调用它，但这似乎更简单并且有效。如果您需要在调用fn. 我不是转发参数，只是传递它们，为简单起见，如有必要，可以轻松更改：

template <typename Fn>
struct FooT {
  Fn &fn;
  FooT(Fn fn):fn(fn){}
  template <typename Type1, typename Type2>
  void operator ()(Type1 x1, Type2 x2) {
    fn(x1,x2);
  }
};

Visual Studio 2012 生成的代码，禁用整个程序优化，仅展开内联 (/Ob1)：

  foo(bar)(1,2);
011E16F0  push        2  
011E16F2  push        1  
011E16F4  call        bar (011E13D0h)  
011E16F9  add         esp,8
于 2015-01-30T08:08:52.213 回答