传递带auto&参数的lambda时，编译器为何选择const成员函数重载？

问题场景 #

我有一个包装容器/视图的类Foo，它的forEach成员函数有两个重载：

• 非const版本：接受能处理ValueType&的函数
• const版本：接受能处理const ValueType&的函数

但调用非const实例的forEach时，传入带auto&参数的lambda，编译器却错误选择了const重载，导致编译失败（因为lambda里修改了参数，而const重载中参数是const引用）。

示例代码：

#include <type_traits>
#include <concepts>
#include <vector>
#include <span>

template <class, class>
struct FunctionWithSignatureOrImplicitlyConvertible : std::false_type {};

template <class Fn, class Ret, class... Args>
struct FunctionWithSignatureOrImplicitlyConvertible<Fn, Ret (Args...)>
{
    static constexpr bool value = requires (Fn&& t, Args&&... args) { { t (args...) } -> std::convertible_to<Ret>; };
};

template <class Fn, class Signature>
concept functionWithSignatureOrImplicitlyConvertible = FunctionWithSignatureOrImplicitlyConvertible<Fn, Signature>::value;

template <class T>
struct Foo
{
    using ValueType = typename T::value_type;
    T& vec;

    Foo (T& src) : vec (src) {}

    template <functionWithSignatureOrImplicitlyConvertible<void (ValueType&)> Fn>
    void forEach (Fn&& fn)
    {
        for (auto& e : vec)
            fn (e);
    }

    template <functionWithSignatureOrImplicitlyConvertible<void (const ValueType&)> Fn>
    void forEach (Fn&& fn) const
    {
        for (auto& e : vec)
            fn (e);
    }
};

int main()
{
    std::vector<float> v { 1.0f, 2.0f, 3.0f, 4.0f };
    std::span s (v);

    Foo a (v);
    Foo b (s);

    a.forEach ([] (auto& e) { e *= 2.0f; }); // 错误：无法给const float&赋值
    a.forEach ([] (float& e) { e *= 2.0f; }); // 正常工作

    b.forEach ([] (auto& e) { e *= 2.0f; }); // 同样错误
    a.forEach ([] (float& e) { e *= 2.0f; }); // 正常工作
    
    return 0;
}

为什么编译器会选择const重载？ #

核心原因是两个重载的约束都被满足，且编译器无法通过模板偏序区分优先级：

1. 带auto&参数的lambda是模板化的调用运算符，它可以接受任何左值引用——包括ValueType&和const ValueType&，因此同时满足两个functionWithSignatureOrImplicitlyConvertible约束。
2. 在重载决议阶段，编译器不会检查lambda函数体的错误（比如赋值const引用），只会判断约束是否满足。
3. 由于两个模板重载都可行，且模板偏序无法区分哪个更特化（能接受const ValueType&的函数必然能接受ValueType&，但反过来不成立，但lambda的模板特性让它适配两种情况），编译器最终错误选择了const版本。

如何让编译器选择非const重载？ #

方法1：给const版本添加排他性约束 #

修改const版本的forEach，让它仅在非const版本不可行时才生效：

template <functionWithSignatureOrImplicitlyConvertible<void (const ValueType&)> Fn>
// 添加约束：仅当函数不能处理非const引用时，才启用该重载
requires (!functionWithSignatureOrImplicitlyConvertible<Fn, void (ValueType&)>)
void forEach (Fn&& fn) const
{
    for (auto& e : vec)
        fn (e);
}

这样，只要传入的函数能处理非const引用，编译器就会优先选择非const版本，只有当函数只能处理const引用时，才会选中const重载。

方法2：明确lambda参数类型 #

这是最直接的临时解决方案——把auto&替换为具体的非const引用类型（比如float&），这样lambda不再满足const版本的约束，编译器会自动选择非const重载。但这种方法不够通用，无法适配任意容器类型。

方法3：优化concept的约束逻辑 #

修改functionWithSignatureOrImplicitlyConvertible，让非const版本的约束更严格，明确要求函数可以修改参数：

template <class Fn, class Ret, class... Args>
struct FunctionWithSignatureOrImplicitlyConvertible<Fn, Ret (Args...)>
{
    static constexpr bool value = requires (Fn&& t, Args&&... args) { 
        { t (args...) } -> std::convertible_to<Ret>;
        // 对于非const引用参数，检查是否可以修改
        (... && (!std::is_const_v<std::remove_reference_t<Args>> || 
                 requires { args = std::declval<std::remove_reference_t<Args>>(); }));
    };
};

这种方法会让非const版本的约束仅对能修改参数的函数生效，从而和const版本的约束明确区分开。

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