为什么bind1st和bind2nd需要常量函数对象？

Question

所以，我正在编写一个 C++ 程序，它可以让我控制整个世界。我已经完成了最终翻译单元的编写，但出现了一个错误：

error C3848: expression having type 'const `anonymous-namespace'::ElementAccumulator<T,BinaryFunction>' would lose some const-volatile qualifiers in order to call 'void `anonymous-namespace'::ElementAccumulator<T,BinaryFunction>::operator ()(const point::Point &,const int &)'
        with
        [
            T=SideCounter,
            BinaryFunction=std::plus<int>
        ]
        c:\program files (x86)\microsoft visual studio 9.0\vc\include\functional(324) : while compiling class template member function 'void std::binder2nd<_Fn2>::operator ()(point::Point &) const'
        with
        [
            _Fn2=`anonymous-namespace'::ElementAccumulator<SideCounter,std::plus<int>>
        ]
        c:\users\****\documents\visual studio 2008\projects\TAKE_OVER_THE_WORLD\grid_divider.cpp(361) : see reference to class template instantiation 'std::binder2nd<_Fn2>' being compiled
        with
        [
            _Fn2=`anonymous-namespace'::ElementAccumulator<SideCounter,std::plus<int>>
        ]

我查看了 binder2nd 的规范，结果是：它需要一个 const AdaptibleBinaryFunction。

所以，没什么大不了的，我想。我只是使用 boost::bind 来代替，对吗？

错误的！现在，我的接管世界的程序编译时间太长（bind 在一个被实例化了很多次的模板中使用）！照这样下去，我的宿敌就要先称霸世界了！我不能让这种事发生——他使用 Java！

那么有人可以告诉我为什么做出这个设计决定吗？这似乎是一个奇怪的决定。我想我现在必须使我的类的一些元素可变...

编辑：有问题的代码：

template <typename T, typename BinaryFunction>
class ElementAccumulator 
    : public binary_function<typename T::key_type, typename T::mapped_type, void>
{
public:
    typedef T MapType;
    typedef typename T::key_type KeyType;
    typedef typename T::mapped_type MappedType;
    typedef BinaryFunction Func;

    ElementAccumulator(MapType& Map, Func f) : map_(Map), f_(f) {}

    void operator()(const KeyType& k, const MappedType& v)
    {
        MappedType& val = map_[k];
        val = f_(val, v);
    }
private:
    MapType& map_;
    Func f_;
};

void myFunc(int n)
{
    typedef boost::unordered_map<Point, int, Point::PointHash> Counter;
    Counter side_count;
    ElementAccumulator<SideCounter, plus<int> > acc(side_count, plus<int>());

        vector<Point> pts = getPts();
    for_each(pts.begin(), pts.end(), bind2nd(acc, n));
}

Answer 1

bind （以及旧的、已弃用的 bind1st 和 bind2nd）是值语义的。返回对象是独立的，它不引用参数，无论是否为 const。

要获取引用语义，请将 std::ref 传递给 bind。

auto defer_by_value = std::bind( fun, foo, bar ); // Copy fun, foo, and bar.

auto defer_by_ref = std::bind( std::ref( fun ), std::ref( foo ), std::ref( bar ) );
                                                  // Observe fun, foo, and bar.

Answer 2

binder2nd ctor 采用一个对 AdaptableBinaryFunction 的常量引用——不是一个const <代码>AdaptableBinaryFunction本身。你的实例化代码怎么样？人们通常不会明确提及 binder2nd ，而是通过便利函数 bind2nd （它仅适用于第二个参数 x 和 typename Operation::second_argument_type(x) 等）。

Answer 3

好吧，尝试一些推论：

任何东西都需要 const 任何东西的原因是允许某人将 const 任何东西传递给它。

您想要传递给“功能”函数的最明显的 const 内容是对临时变量的引用。

特别是，如果 bind1st 和 中的其他内容采用非常量引用参数，那么您无法将它们链接在一起以函数式风格进行编程。函数式风格讨厌在一个语句中捕获变量中的临时值，然后“稍后”在“下一个”语句中修改该变量的想法。所有这些都非常必要且有副作用。

不幸的是，这意味着在定义时，函子的operator()在这种情况下需要是const，并且可能在许多其他情况下。你的不是。

boost::bind 是否允许 const 作为相关模板类型的一部分？如果是这样，那么 可能不会这样做，因为 boost::bind 是在人们更加了解如何充分利用模板后设计的。或者也许 bind1st 是用更纯粹的函数式思维设计的，因此没有副作用，因此为什么不应该一切都是 const 呢？我可能错过了问题的部分要点 - 我从您的代码示例中看到为什么要使用参数绑定，但我认为名为 的标头并不明显寻找涉及累加器的任何内容的正确位置;-)