模板参数推导失败，使用函数指针作为参数

Question

我编写了许多模板函数。示例：

template <typename T>
inline int Foo(T* t, unsigned char** p, size_t* size, size_t (*MyHandler)(T*))
{
    ...
}

template <>
inline int Foo<Bar>(Bar* t, unsigned char** p, size_t* size, size_t (*MyHandler)(Bar*))
{
    ...
}

如果我使用显式模板参数调用这些函数，那么一切正常，即

Foo<Bar>(&myBar, pBuffer, size, FooFoo<Bar>);

FooFoo<T> 是一个不同的模板函数

如果用户不需要跟踪类型，那将是非常有利的。所以我想使用以下语法：

Foo(&myBar, pBuffer, size, FooFoo);

但是，这条线却造成了一对

• C2784：无法从 'Bar *' 推导出 'T *' 的模板参数
• C2796：不能使用函数模板 'size_t FooFoo(T *) 作为函数参数

与Foo 一样，存在一个专门化FooFoo<Bar>

据我所知，应该可以推导出 T，因为第一个参数的类型为 T* - 或者该函数指针是否与推导混淆？

任何提示将不胜感激。

更新 3 根据@Yakk 建议的更改请求的 MCVS 最终有效！

#include <stdio.h>

struct Bar
{
    int a;
    int b;
    int c;
};


template<class T>struct id_t{typedef T type;}; 

template <typename T>
inline size_t FooFoo(T* t)
{
    printf("FooFoo calculating size of T...\r\n", sizeof(T));
    return sizeof(T);
}

template <>
inline size_t FooFoo<Bar>(Bar* t)
{
    printf("FooFoo calculating size of Bar...\r\n", sizeof(Bar));
    return sizeof(Bar);
}

template <typename T>
inline int Foo(T* t, unsigned char** p, size_t* size, typename id_t<size_t (*)(T*)>::type MyHandler)
{
    printf("Foo telling size of T: %u\r\n", MyHandler(t));
    return 0;
}

template <>
inline int Foo<Bar>(Bar* t, unsigned char** p, size_t* size, typename id_t<size_t (*)(Bar*)>::type MyHandler)
{
    printf("Foo telling size of Bar: %u\r\n", MyHandler(t));
    return 0;
}



int main(int argc, char* argv[])
{
    int i;
    Bar myBar;

    Foo<Bar>(&myBar, nullptr, 0, FooFoo<Bar>); //  works
    Foo<int>(&i, nullptr, 0, FooFoo<int>); // works

    Foo(&myBar, nullptr, 0, FooFoo<Bar>); //  works
    Foo(&i, nullptr, 0, FooFoo<int>); // works


    Foo(&myBar, nullptr, 0, FooFoo);    // error C2896: 'int Foo(T *,unsigned char **,size_t *,size_t (__cdecl *)(T *))' : cannot use function template 'size_t FooFoo(T *)' as a function argument
                                        // error C2784: 'int Foo(T *,unsigned char **,size_t *,size_t (__cdecl *)(T *))' : could not deduce template argument for 'T *' from 'Bar *'

    Foo(&i, nullptr, 0, FooFoo);        // error C2896: 'int Foo(T *,unsigned char **,size_t *,size_t (__cdecl *)(T *))' : cannot use function template 'size_t FooFoo(T *)' as a function argument
                                        //error C2784: 'int Foo(T *,unsigned char **,size_t *,size_t (__cdecl *)(T *))' : could not deduce template argument for 'T *' from 'int *'

    return 0;
}

非常感谢！

Answer 1

所有参数在推导时具有相同的权重，并且是独立推导的。要阻止使用特定参数进行演绎，请执行以下操作：

template<class T>struct id_t{typedef T type;};
template<class T>using block_deduction=typename id_t<T>::type;

现在拿size_t (*MyHandler)(T*) 做吧：

block_deduction<size_t (*)(T*)> MyHandler

或者在非 C++11 编译器中：

typename id_t<size_t (*)(T*)>::type MyHandler

这样做是将MyHandler 参数的类型放入非推导上下文中。因此，编译器不会尝试，而是使用第一个参数的推导来确定T。然后生成MyHandler 的类型。然后根据签名解决您传递的重载集，并且一切正常（可能）。

Answer 2

您的问题不是T=Bar 对Foo 的扣除——而是FooFoo 的扣除。