3

有两种方法可以创建仿函数（一个保存状态的函数）：

  1. 绑定一个函数并定义一个状态：bind(f, _1, state)

    双g（双x，双状态）{返回x+状态；} 函数 f = 绑定（g，_1，状态）；

  2. 使用()运算符和一个类：

struct f { 
  double state; 
  f(double state_):state(state_) {} 
  double operator()(double x) {return x+state;}
};

我发现bind-method 写起来更快，但我想知道是否有一些隐藏的石头，因为在文学中的大部分时间我都将函子视为类的()运算符。

4

3 回答 3

3

3.方式是一个lambda表达式：

auto f = [state]( double x ) { return x * state; };
于 2013-08-11T10:36:31.803 回答
1

我认为这bind是受函数式语言的启发（正如头文件名告诉你的那样）。我认为它是相当等价的，因为它是一个模板函数，但可能通过内置调用进行了优化......

这是我第一次看到这个功能，所以我需要看一下 asm 看看有什么不同，然后我会重新发布;）

尽管如此，它不允许您在仿函数中使用其他方法，因此operator()仍然需要许多用途

[编辑] 好的，我看到 asm : bind 添加了很多代码，因为它的模板与“经典方式”相比。因此，我建议你使用 strucs 的方式来使用（即只是一个仿函数）。此外，阅读这样的代码更容易理解。如果您从参数替换中获利，则绑定很好，但为了简单使用，它是切割奶酪的激光佳能：P [/EDIT]

于 2013-08-11T08:22:10.717 回答
0

看起来struct是更快的方法：

11:01:56 ~/try 
> g++ -std=c++11 main.cpp ; ./a.out
in 2265 ms, functor as a struct result = 1.5708e+16
in 31855 ms, functor through bind result = 1.5708e+16
11:02:33 ~/try 
> clang++ -std=c++11 main.cpp ; ./a.out
in 3484 ms, functor as a struct result = 1.5708e+16
in 21081 ms, functor through bind result = 1.5708e+16

编码：

#include <iostream>
#include <functional>
#include <chrono>

using namespace std;
using namespace std::placeholders;
using namespace std::chrono;

struct fs {
  double s;
  fs(double state) : s(state) {}
  double operator()(double x) {
    return x*s;
  }
};

double fb(double x, double state) {
  return x*state;
}

int main(int argc, char const *argv[]) {
  double state=3.1415926;

  const auto stp1 = system_clock::now();
  fs fstruct(state);
  double sresult;
  for(double x=0.0; x< 1.0e8; ++x) {
    sresult += fstruct(x);
  }
  const auto stp2 = high_resolution_clock::now();
  const auto sd = duration_cast<milliseconds>(stp2 - stp1);  
  cout << "in " << sd.count() << " ms, "; 
  cout << "functor as a struct result = " << sresult << endl;

  const auto btp1 = system_clock::now();
  auto fbind = bind(fb, _1, state);
  double bresult;
  for(double x=0.0; x< 1.0e8; ++x) {
    bresult += fbind(x);
  }
  const auto btp2 = high_resolution_clock::now();
  const auto bd = duration_cast<milliseconds>(btp2 - btp1);  
  cout << "in " << bd.count() << " ms, "; 
  cout << "functor through bind result = " << bresult << endl;

  return 0;
}

更新 (1)

也可以将函数作为函数对象：

struct fbs {
  double operator()(double x, double state) const {
    return x*state;
  }
};

在 main.cpp 中：

  const auto bstp1 = system_clock::now();
  auto fbindstruct = bind(fbs(), _1, state);
  double bsresult;
  for(double x=0.0; x< 1.0e8; ++x) {
    bsresult += fbindstruct(x);
  }
  const auto bstp2 = high_resolution_clock::now();
  const auto bsd = duration_cast<milliseconds>(bstp2 - bstp1);  
  cout << "in " << bsd.count() << " ms, "; 
  cout << "functor through bind-struct result = " << bsresult << endl;

没有改变速度：

> g++ -std=c++11 main.cpp ; ./a.out
hi
in 2178 ms, functor as a struct result = 1.5708e+16
in 31972 ms, functor through bind result = 1.5708e+16
in 32083 ms, functor through bind-struct result = 1.5708e+16
12:15:27 ~/try 
> clang++ -std=c++11 main.cpp ; ./a.out
hi
in 3758 ms, functor as a struct result = 1.5708e+16
in 23503 ms, functor through bind result = 1.5708e+16
in 23508 ms, functor through bind-struct result = 1.5708e+16

更新 (2)

在相似的时间添加优化结果：

> g++ -std=c++11 -O2 main.cpp ; ./a.out
hi
in 536 ms, functor as a struct result = 1.5708e+16
in 510 ms, functor through bind result = 1.5708e+16
in 472 ms, functor through bind-struct result = 1.5708e+16
12:31:33 ~/try 
> clang++ -std=c++11 -O2 main.cpp ; ./a.out
hi
in 388 ms, functor as a struct result = 1.5708e+16
in 419 ms, functor through bind result = 1.5708e+16
in 456 ms, functor through bind-struct result = 3.14159e+16

GCC 4.8.1 和 Clang 3.3

注意Clang 3.3 为“bind-struct”情况给出了错误的结果

更新(3)

有更多的性能测试是否有一个基于宏的适配器来从一个类中创建一个仿函数？

于 2013-08-11T18:06:35.590 回答