C++ 避免接受lambda的方法的常量/非常量重复

class Frame

表示具有

p

类型像素的图像。由于底层数据缓冲区格式的一些灵活性，遍历其像素的算法非常重要

template <typename P, bool RM = true> // P is pixel type; RM = is_row_major
class Frame {

    // ...

    template<typename F>
    void iterate(F f) { // iterate in a way that is performant for this buffer
        if (stride == (RM ? size.w : size.h)) {
            auto n = size.area();
            for (index_t k = 0; k < n; k++) {
                f(view[k]);
            }
        }
        else {
            auto s = static_cast<index_t>(stride)*(RM ? size.h : size.w);
            for (index_t k0 = 0; k0 < s; k0 += stride) {
                auto m = k0 + (RM ? size.w : size.h);
                for (index_t k = k0; k < m; k++) {
                    f(view[k]);
                }
            }
        }
    }
}

template//P为像素类型；RM=是第二行还是第三行
类框架{
// ...
模板
void iterate（F）{//以对该缓冲区执行的方式进行迭代
如果（步幅==（RM？size.w：size.h））{
自动n=大小。面积（）；
对于（索引k=0；k

---

我希望能够调用

iterate（fc）const

和

iterate（f）

（分别使用lambda签名

fc（const p&）

和

f（p&）

）。我可以复制整个函数体并将

const

附加到签名上，但是有更好的方法吗？

无法推断成员函数的

const

属性。但是，使用转发引用可以推断函数参数的

成本。因此，您可以将对象类型作为参数委托给函数，并转发所有其他参数。这样，重复的代码就变得微不足道了。如果函数需要访问
private
或
protected
成员，您只需将其设置为（可能
private
）
静态成员：

template <typename T, bool PM = true>
class Frame {
    template <typename F1, typename F2>
    static void iterateTogether(F1&& f1, F2&& f2) {
        // actual implementation goes here
    }
public:
    template <typename F2>
    void iterateTogether(F2&& other){
        iterateTogether(*this, std::forward<F2>(other));
    }
    // ...
 };

模板
类框架{
模板
静态无效迭代器集合（F1&&F1，F2&&F2）{
//实际实现在这里
}
公众：
模板
无效迭代对象（F2和其他）{
iterateTogether（*this，std:：forward（other））；
}
// ...
};

上面使用的实现还允许参数具有不同的
const
ness。如果要将参数约束为真正的
Frame
的特化，则需要约束函数，但这很容易实现

我个人的偏好是，不管怎样，只拥有微不足道的成员，并将任何非微不足道的事情委托给通用算法。我的偏好是类只是保持它们的不变量，而有趣的用法是通过算法实现的。
这有帮助吗？（如果没有，那么我显然还没有理解这个问题——你能说得更清楚一点，并尽可能减少你的例子吗？@davidhigh不确定。我经常在简单的getter上使用它。在这里也使用
const\u cast
安全吗？在什么地方使用？坦白说，我还不明白这个问题。。。在你的问题中，你能举一个例子说明你想做什么，只有两个
操作符+=
成员，一个常量，一个非常量吗？@davidhigh对我来说
操作符+=
本质上是非常量的。我想要的是一个
iterateTogether（）const
，而不复制整个方法。为什么不能有一个
iterateTogether
函数，即
const
？从非常量函数调用
const
成员函数没有问题。