将重载的 CRTP 类成员方法传递给 lambda

Question

考虑一下：

template<typename T>
struct base_t
{
    auto& f(int x) { return (T&)*this; }
    auto& f(char x) { return (T&)*this; }
};

struct derived_t : base_t<derived_t>
{

};

void test()
{
    derived_t instance;

    auto lambda = [&](derived_t&(derived_t::*g)(char))
    {
        (instance.*g)('a');

        //instance.f('a');
    };

    lambda(&derived_t::f);
}

如果不在该特定行 (//instance.f('a');) 中进行评论，我会收到以下错误 (MSVC 2019)：

error C2664: 'void test::<lambda_1>::operator ()(derived_t &(__cdecl derived_t::* )(char)) const': cannot convert argument 1 from 'overloaded-function' to 'derived_t &(__cdecl derived_t::* )(char)'

当该行没有被注释掉时，它编译得很好。

为什么在lambda 中引用f 会神奇地允许编译器转换这个重载函数？

此外，没有 CRTP，这根本不会发生。

编辑：此外，正如@Jarod42 所指出的，

• 明确返回类型 auto& -> T& 解决了这个问题。

• 如果您使用命名函数而不是 lambda，问题就会消失。所以显然 lambda 和模板的交互是相关的。

Answer 1

模板机制在使用类和函数时对其进行实例化。 使用相同的机制来评估关键字 auto 背后的类型。

在您的情况下，base_t<T>::f 函数的返回类型是 auto&，并且需要计算函数调用。 因此，当您注释掉对它的唯一调用 (instance.f('a');) 时，无法计算函数的实际签名，并且编译器无法判断它是否可以转换为 derived_t&(derived_t::*g)(char)。

如果您将base_t<T>::f 函数定义如下，则可以注释掉instance.f('a');：

template<typename T>
struct base_t
{
    T& f(int) { return *static_cast<T*>(this); }
    T& f(char) { return *static_cast<T*>(this); }
};

这里的类型是在专用类型 base_t<derived_t> 的实例化时推断出来的，而不是在调用 f 函数时推断出来的，因此编译器可以计算出它到函数类型 derived_t&(derived_t::*g)(char) 的转换，而不必在你的代码。