C 误差C2064用于C 模板中的嵌套结合

c++ error C2064 for nested bind in C++ template

本文关键字：嵌套 结合 误差 C2064 用于      更新时间：2023-10-16

如果我编译了下面的代码，我会得到一个：Microsoft Visual Studio 12.0 vc include xrefwrap（58）：错误c2064：术语未评估为2个参数的函数

在累积算法的调用中，如果我将代码更改为 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;
}

这将修复它：

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));

...但是我希望你同意这是可怕的。

相关文章：