你的问题出在两个operator|重载之间存在匹配歧义——当你传入一个返回void的lambda（比如打印操作）时，编译器无法判断该调用哪个版本：两个模板重载都能推导出匹配的参数类型，没有明确的优先级。

问题根源 #

你写的两个重载：

void operator | ( auto& v, auto map ) { ... }
template <typename T>
T operator | ( T& vet, auto map) { ... }

对于v | [] (int x) { cout << x << endl; }这个表达式，两个模板都能成功推导参数：

• 第一个重载推导auto& v为vector<int>&，auto map为你的lambda类型；
• 第二个重载推导T为vector<int>，auto map同样为你的lambda类型。

编译器没有足够的规则来选择其中一个，因此抛出歧义错误。

解决方案：用SFINAE区分函数返回类型 #

我们可以利用**SFINAE（替换失败不是错误）**技术，根据lambda的返回类型来约束不同的重载，让它们互斥匹配：

1. 处理返回void的操作（如打印）：仅当lambda返回void时，触发这个重载，执行遍历调用操作，无返回值。
2. 处理返回非void的操作（如过滤、映射）：当lambda返回非void时，触发这个重载，根据返回值类型自动处理过滤（返回bool）或映射（返回元素类型），并返回新的容器。

修改后的完整代码：

#include <iostream>
#include <functional>
#include <type_traits>
#include <vector>
using namespace std;

// 重载1：处理返回void的操作（如打印）
template <typename Container, typename Func>
std::enable_if_t<std::is_void_v<std::invoke_result_t<Func, typename Container::value_type>>>
operator|(Container& v, Func map) {
    for (auto x : v) {
        map(x);
    }
}

// 重载2：处理返回非void的操作（过滤/映射）
template <typename Container, typename Func>
auto operator|(Container& v, Func map) -> std::vector<std::conditional_t<
    std::is_same_v<std::invoke_result_t<Func, typename Container::value_type>, bool>,
    typename Container::value_type,
    std::invoke_result_t<Func, typename Container::value_type>
>> {
    using ResultType = std::invoke_result_t<Func, typename Container::value_type>;
    using ElemType = std::conditional_t<std::is_same_v<ResultType, bool>, typename Container::value_type, ResultType>;
    std::vector<ElemType> aux;

    for (auto x : v) {
        auto res = map(x);
        // 编译时判断：如果是过滤（返回bool），则保留符合条件的元素
        if constexpr (std::is_same_v<ResultType, bool>) {
            if (res) {
                aux.push_back(x);
            }
        }
        // 否则是映射，直接加入转换后的元素
        else {
            aux.push_back(res);
        }
    }
    return aux;
}

int main () {
    vector<int> v{1,2,3,4,5,6,7,8} ;
    
    // 过滤偶数后打印
    v | [](int x) { return x % 2 == 0; } | [](int x) { cout << x << " "; };
    cout << endl;
    
    // 直接打印所有元素
    v | [](int x) { cout << x << " "; };
    cout << endl;
    
    // 映射：每个元素乘2后打印
    v | [](int x) { return x * 2; } | [](int x) { cout << x << " "; };
    cout << endl;
    
    return 0;
}

关键细节说明 #

• std::invoke_result_t：用于获取lambda的返回类型，这是判断重载匹配的核心依据。
• std::enable_if_t：让第一个重载仅在lambda返回void时生效，避免和第二个重载产生冲突。
• std::conditional_t：自动判断返回容器的元素类型——如果是过滤操作（返回bool），保留原容器的元素类型；如果是映射操作，使用lambda返回的元素类型。
• if constexpr：在编译时区分过滤和映射逻辑，避免运行时分支判断的开销。

这样修改后，编译器就能清晰地根据lambda的返回类型选择对应的重载，解决了歧义问题，同时也实现了你想要的管道过滤、打印、映射功能。

内容的提问来源于stack exchange，提问作者João Maia