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

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 的类型。然后根据签名解析您传递的重载集，一切正常(可能)。