容器与初始值类型不同时std::reduce编译失败的跨平台问题排查

问题场景 #

使用std::reduce时遇到跨平台差异：调用在Visual Studio中编译通过，但在GCC下编译失败。具体场景为：以整数作为初始值，对存储std::pair<int, bool>的容器执行reduce操作，自定义二元操作符签名为int (int &&, const std::pair<int, bool> &)。代码包含自定义reduce实现，可通过宏切换使用自定义版本或标准库版本。

测试代码 #

#include <iostream>
#include <algorithm>

#include <numeric>
#include <vector>

namespace MyImpl
{
    template <typename IIter, typename T, typename BinaryOp>
    T reduce(IIter first, IIter last, T val, const BinaryOp &bOp)
    {
        for (; first != last; ++first)
            val = bOp(std::move (val), *first);
    
        return val;
    }    
}

int main ()
{
    std::vector<std::pair<int, bool>> vv {std::pair{1, false}, std::pair{2, true}, std::pair{-1, false}, std::pair{7, true}, std::pair{10, false}, };

#define MY_IMPLEMENTATION
#ifdef MY_IMPLEMENTATION
    // 自定义实现可得到预期结果
    std::cout << MyImpl::reduce (vv.begin (), vv.end (), 0, [] (auto &&value, const auto &ve)
    {
        return (ve.second ? (value + ve.first) : (value));
    });
#else
    // std版本编译报错
    std::cout << std::reduce (vv.begin (), vv.end (), 0, [] (auto &&value, const auto &ve)
    {
        return (ve.second ? (value + ve.first) : (value));
    });
#endif

    return 0;
}

GCC编译错误信息 #

main.cpp: In instantiation of 'main()::<lambda(auto:16&&, const auto:17&)> [with auto:16 = std::pair<int, bool>&; auto:17 = int]':
/usr/local/include/c++/12.1.0/type_traits:2565:26:   required by substitution of 'template<class _Fn, class ... _Args> static std::__result_of_success<decltype (declval<_Fn>()((declval<_Args>)()...)), std::__invoke_other> std::__result_of_other_impl::_S_test(int) [with _Fn = main()::<lambda(auto:16&&, const auto:17&)>&; _Args = {std::pair<int, bool>&, int&}]'
/usr/local/include/c++/12.1.0/type_traits:2576:55:   required from 'struct std::__result_of_impl<false, false, main()::<lambda(auto:16&&, const auto:17&)>&, std::pair<int, bool>&, int&>'
/usr/local/include/c++/12.1.0/type_traits:3050:12:   recursively required by substitution of 'template<class _Result, class _Ret> struct std::__is_invocable_impl<_Result, _Ret, false, std::__void_t<typename _CTp::type>> [with _Result = std::__invoke_result<main()::<lambda(auto:16&&, const auto:17&)>&, std::pair<int, bool>&, int&>; _Ret = int]'
/usr/local/include/c++/12.1.0/type_traits:3050:12:   required from 'struct std::is_invocable_r<int, main()::<lambda(auto:16&&, const auto:17&)>&, std::pair<int, bool>&, int&>'
/usr/local/include/c++/12.1.0/type_traits:3292:44:   required from 'constexpr const bool std::is_invocable_r_v<int, main()::<lambda(auto:16&&, const auto:17&)>&, std::pair<int, bool>&, int&>'
/usr/local/include/c++/12.1.0/numeric:283:21:   required from 'constexpr _Tp std::reduce(_InputIterator, _InputIterator, _Tp, _BinaryOperation) [with _InputIterator = __gnu_cxx::__normal_iterator<pair<int, bool>*, vector<pair<int, bool> > >; _Tp = int; _BinaryOperation = main()::<lambda(auto:16&&, const auto:17&)>]'

问题原因 #

GCC的行为符合C++标准，而Visual Studio的实现未严格遵循标准要求：

• C++标准规定std::reduce的二元操作符必须可交换且可结合，标准库实现有权以任意顺序组合元素，包括：
  1. 将两个容器中的std::pair<int, bool>元素先组合（此时操作符的两个参数都是std::pair）
  2. 交换累积值与元素的顺序（即调用bOp(*first, val)而非bOp(val, *first)）
• 你的lambda仅支持(int &&, const std::pair<int, bool> &)的参数顺序，无法处理上述任意一种情况，因此GCC编译报错。
• Visual Studio的std::reduce实现可能采用了顺序执行的逻辑（和你的自定义版本一致，始终用累积值逐个与容器元素组合），因此未触发参数不兼容的问题，但这属于非标准实现行为。

解决方案 #

方案1：调整lambda以支持任意参数顺序 #

修改lambda，使其能处理int与std::pair的任意组合顺序，满足std::reduce的可交换要求：

[] (auto &&a, auto &&b) {
    if constexpr (std::is_same_v<std::decay_t<decltype(a)>, int>) {
        // 处理 (int, pair) 的情况
        return b.second ? (a + b.first) : a;
    } else {
        // 处理 (pair, int) 或 (pair, pair) 的情况
        if constexpr (std::is_same_v<std::decay_t<decltype(b)>, int>) {
            return a.second ? (a.first + b) : b;
        } else {
            // 若需要支持两个pair组合（标准允许），可补充逻辑
            auto sum = 0;
            if (a.second) sum += a.first;
            if (b.second) sum += b.first;
            return sum;
        }
    }
}

方案2：改用std::accumulate替代std::reduce #

如果你需要严格的顺序执行逻辑（和自定义reduce一致），std::accumulate才是符合需求的标准算法：它保证按容器顺序将累积值与每个元素依次组合，不需要操作符具备可交换性。替换后代码如下：

std::cout << std::accumulate(vv.begin(), vv.end(), 0, [] (auto &&value, const auto &ve)
{
    return (ve.second ? (value + ve.first) : (value));
});

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