如何避免Frame类中接受Lambda的迭代方法出现const/non-const代码重复？

在C++里处理这类const与非const成员函数代码重复的问题，最优雅且安全的方式是把核心迭代逻辑提取到一个私有模板函数中，让const和非const版本的iterate都调用这个模板，彻底避免冗余代码。下面是具体实现思路：

步骤1：提取核心迭代模板函数 #

首先在Frame类中添加一个私有模板函数（比如叫do_iterate），它接受一个带cv限定的Frame引用（可以是Frame或const Frame）以及回调函数，负责执行所有实际的迭代逻辑。模板会自动根据传入的Frame类型，适配像素的const/非const访问权限。

template <typename P, bool RM = true>
class Frame {
private:
    // 核心迭代逻辑：T是Frame的cv限定版本（const或非const）
    template<typename T, typename F>
    static void do_iterate(T& frame, F f) {
        // 这里放原来的高效迭代逻辑，比如：
        if (frame.stride == (RM ? frame.size.w : frame.size.h)) {
            auto n = frame.size.area();
            for (index_t k = 0; k < n; k++) {
                // 根据T的cv属性，自动适配像素的const/非const访问
                f(frame.buffer[k]); // 假设buffer是存储像素的成员，按需调整
            }
        } else {
            // 处理非连续缓冲区的迭代逻辑，同样复用一份代码
            if constexpr (RM) {
                for (index_t y = 0; y < frame.size.h; y++) {
                    auto row_ptr = frame.buffer + y * frame.stride;
                    for (index_t x = 0; x < frame.size.w; x++) {
                        f(row_ptr[x]);
                    }
                }
            } else {
                // 列优先的迭代逻辑
                for (index_t x = 0; x < frame.size.w; x++) {
                    auto col_ptr = frame.buffer + x * frame.stride;
                    for (index_t y = 0; y < frame.size.h; y++) {
                        f(col_ptr[y]);
                    }
                }
            }
        }
    }

public:
    // ... 其他类成员 ...

步骤2：实现const和non-const版本的iterate #

接下来在public区分别实现两个版本的iterate，它们只需要调用do_iterate并传递自身和回调函数即可，不需要重复写迭代逻辑：

// 非const版本：允许回调修改像素
    template<typename F>
    void iterate(F f) {
        do_iterate(*this, std::move(f));
    }

    // const版本：回调只能读取像素
    template<typename F>
    void iterate(F f) const {
        do_iterate(*this, std::move(f));
    }

    // ... 其他类成员 ...
};

为什么这个方案好用？ #

• 无冗余代码：核心迭代逻辑只维护一份，后续修改迭代规则时，只需要改动do_iterate即可，大幅降低维护成本。
• 类型安全：完全依赖模板参数推导适配const/非const属性，避免了手动使用const_cast带来的潜在风险（比如错误移除const限定导致未定义行为）。
• 性能无损：模板函数在编译期会被实例化为对应cv版本的代码，和手写两个版本的性能完全一致。

可选替代方案（基于const版本复用） #

如果你更倾向于以const版本为基础，也可以让非const版本调用const版本，通过包装回调来调整参数的const属性：

template<typename P, bool RM = true>
class Frame {
public:
    // const版本：完整迭代逻辑
    template<typename F>
    void iterate(F f) const {
        if (stride == (RM ? size.w : size.h)) {
            auto n = size.area();
            for (index_t k = 0; k < n; k++) {
                f(buffer[k]);
            }
        } else {
            // ... 非连续缓冲区逻辑 ...
        }
    }

    // 非const版本：复用const版本逻辑
    template<typename F>
    void iterate(F f) {
        // 将this转为const调用const版本，同时把回调包装为接受const像素并转成非const
        const_cast<const Frame*>(this)->iterate([&f](const P& pixel) {
            f(const_cast<P&>(pixel));
        });
    }
};

不过这种方案的可读性稍差，且对回调的包装可能带来微小的性能开销（大部分编译器会优化掉），所以更推荐第一种模板提取的方案。

内容的提问来源于stack exchange，提问作者Museful