C++ 模板中嵌套绑定(bind)的 C++ 错误 C2064

Question

如果我编译下面的代码，我会得到:microsoft visual studio 12.0\vc\include\xrefwrap(58): error C2064: term does not evaluate to a function takes 2 arguments

在累积算法的调用中，如果我将代码更改为 function<double(double, Position const&) > f = bind(sum, placeholders::_1, bind(mem_fn(&Position::getBalance), placeholders::_2));double sum = accumulate(balances.begin(), balances.end(), 0., f);一切都很好。我也尝试使用非成员函数，但它也不起作用。

class Position
{
private:
    double m_balance;
public:
    Position(double balance) :
        m_balance(balance)
    {}

    double getBalance() const
    {
        return m_balance;
    }
};

static double sum(double v1, double v2)
{
    return v1 + v2;
}

int main(int argc, char ** argv)
{
    std::vector< Position > balances;
    for (size_t i = 0; i < 10; i++)
    {
        balances.push_back(Position(i));
    }

    double sum = accumulate(balances.begin(), balances.end(), 0., bind(sum, placeholders::_1, bind(mem_fn(&Position::getBalance), placeholders::_2)));
    cout << sum << endl;
    return 0;
}

Answer 1

这将解决它:

double sum = accumulate(balances.cbegin(), 
                        balances.cend(), 
                        0.0 , 
                        std::bind(std::plus<>(), 
                                  placeholders::_1,
                                  std::bind(&Position::getBalance, placeholders::_2)));

或者我们可以善待我们的程序员同事:

auto add_balance = [](auto x, auto& position) {
  return x + position.getBalance();
};

double sum = accumulate(balances.cbegin(), 
                        balances.cend(), 
                        0.0 , 
                        add_balance);

或者我们当然可以内联 lambda。没有性能差异。哪个看起来更清晰将是个人喜好问题。

double sum = accumulate(balances.cbegin(), 
                        balances.cend(), 
                        0.0 , 
                        [](auto x, auto& position) 
                        {
                          return x + position.getBalance();
                        });

或者我们可以编写一个复杂的仿函数来完成类似的工作。这是 lambda 之前的方式:

template<class Op>
struct PositionOp
{
  using mfp_type = double (Position::*)() const;

  PositionOp(Op op, mfp_type mfp) : op(op), mfp(mfp) {}

  template<class T>
  auto operator()(T x, const Position& pos) const {
    return op(x, (pos.*mfp)());
  }

  Op op;
  mfp_type mfp;
};

template<class Op>
auto position_op(Op op, double (Position::*mfp)() const)
{
  return PositionOp<Op>(op, mfp);
}

...

double sum = accumulate(balances.cbegin(), 
                        balances.cend(), 
                        0.0 , 
                        position_op(std::plus<>(), &Position::getBalance)); 

...但我希望你会同意这很可怕。