C++ 减少过载功能的冗余代码（const&；vs&；） 模板 TriFunc进程\u三个连续\u通道\u impl（cv:：Mat&input，TriFunc func） { int const total=input.total（）； auto*input_ptr=input.ptr（0）； 对于（int index=0；index！=total；++index）{ func（*input_ptr，*（input_ptr+1），*（input_ptr+2））； 输入_ptr+=3； } 返回函数； } /** *过载，还没有找到一个好的解决方案来减少冗余代码 */ 模板 TriFunc进程\u三个连续\u通道\u impl（cv:：Mat const&input，TriFunc func） { int const total=input.total（）； 自动常数*input_ptr=input.ptr（0）； 对于（int index=0；index！=total；++index）{ func（*input_ptr，*（input_ptr+1），*（input_ptr+2））； 输入_ptr+=3； } 返回函数； }

我想减少冗余代码，但找不到好的解决方案

template<typename T, typename TriFunc>
TriFunc process_three_continuous_channels_impl(cv::Mat &input, TriFunc func)
{
    int const total = input.total();
    auto *input_ptr = input.ptr<T>(0);
    for(int index = 0; index != total; ++index){
        func(*input_ptr, *(input_ptr + 1), *(input_ptr + 2));
        input_ptr += 3;
    }

    return func;
}

/**
 * overload, haven't find a good solution to reduce redundancy codes yet
 */
template<typename T, typename TriFunc>
TriFunc process_three_continuous_channels_impl(cv::Mat const &input, TriFunc func)
{       
    int const total = input.total();
    auto const *input_ptr = input.ptr<T>(0);
    for(int index = 0; index != total; ++index){
        func(*input_ptr, *(input_ptr + 1), *(input_ptr + 2));
        input_ptr += 3;
    }

    return func;
}

模板
TriFunc进程\u三个连续\u通道\u impl（cv:：Mat const&input，TriFunc func）
{
返回过程三个连续通道输入（常量转换（输入，函数））；
}

这是行不通的，因为func可以在const_cast之后更改输入数据 将非常量cv:：Mat强制转换为常量也无法工作，这样func将无法运行

---

改变输入的数据。有什么建议吗？

如果C++11是您的一个选项，那么“完美转发”可以在这里工作：

template<typename T, typename TriFunc>
TriFunc process_three_continuous_channels_impl(cv::Mat const &input, TriFunc func)
{
   return process_three_continuous_channels_impl<T>(const_cast<cv::Mat&>(input, func));
}

模板
TriFunc包装器（cv:：Mat&&input，TriFunc-func）
{
返回过程\u三个连续\u通道\u导入(
标准：：转发（输入），func）；
}

您可以将

cv:：Mat

参数设置为对模板参数类型的引用

template <typename T, typename TriFunc>
TriFunc wrapper(cv::Mat && input, TriFunc func)
{
    return process_three_continuous_channels_impl<T>(
        std::forward(input), func);
}

模板
TriFunc进程\u三个连续\u通道\u impl（Mat&input，TriFunc-func）
{
int const total=std:：forward（输入）.total（）；
自动输入\u ptr=std:：forward（输入）。模板ptr（0）；
对于（int index=0；index！=total；++index）{
func（*input_ptr，*（input_ptr+1），*（input_ptr+2））；
输入_ptr+=3；
}
返回函数；
}

您是否尝试过另一种方法？从“非常量”调用“常量”？我已经尝试过了，这不起作用，因为functor“func”将无法更改“input”的数据。C++11是我的一个选项，但我不知道这如何解决问题？即使std:：forward可以识别输入是“const&”或“&”，我仍然需要两个不同的实现“处理三个连续通道”“谢谢，这对我来说很好，但是有一些细节需要解决。”。ptr应该是.template ptr。我发现了一些东西，std:：forward应该能够删除，因为std:：forward将添加&或者什么都不做，它不会影响输入的常量。如果我是，请纠正我woring@StereoMatching：它不会影响常量，但可能会影响左值或右值。如果这对您不重要，请随意删除它。

template<typename Mat, typename T, typename TriFunc>
TriFunc process_three_continuous_channels_impl(Mat&& input, TriFunc func)
{
    int const total = std::forward<Mat>(input).total();
    auto input_ptr = std::forward<Mat>(input).template ptr<T>(0);
    for(int index = 0; index != total; ++index){
        func(*input_ptr, *(input_ptr + 1), *(input_ptr + 2));
        input_ptr += 3;
    }

    return func;
}