函数模板专业化失败？

Question

#include <iostream>

template <class T> 
void foo(T) {
    std::cout << "foo(T)" << std::endl;
}

template <class T> 
void foo(T*) { //#3
    std::cout << "foo(T*)" << std::endl;
}

#define TEST

#ifdef TEST
template <> 
void foo(int*) { //#1
    std::cout << "foo(int*)" << std::endl;
}
#else
template <>
void foo<int*>(int*) { //#2
    std::cout << "foo<int*>(int*)" << std::endl;
}
#endif

int main(int argc, char **argv) {
    int* p = 0;
    foo(p);
    return 0;
}

上面的#1和#2有什么区别？如果我定义 TEST，则 #1 有效，但如果我将其注释掉，#3 有效。在这里编写函数模板专业化的正确方法是什么？

Answer 1

#1 声明 #3 的函数模板特化并自动推导模板参数。 #2 是您为 T=int* 定义的第一个模板（没有编号的模板，我们称之为 #0）的特化。它不能是 #3 的特化，因为用指定的 int* 替换 T 会导致出现 int** 参数。

当您调用 foo 时，重载解析现在首先选择最合适的基本模板，然后检查该模板是否有任何现有的专业化。定义了 TEST 后，有两个基本模板（#0 和 #3），#3 更匹配并被选中。然后编译器检查该模板的特殊化，#1 更适合并且正在被调用。

如果没有定义 TEST，仍然有两个基本模板（#0 和 #3），并且 #3 是更好的匹配并被选中。然后编译器检查该模板的特化，但由于 #2 特化 #0 而不是 #3，因此不考虑它，并且 #3 结束调用。

这是为什么不专门化函数模板的经典示例。那里对问题进行了更详细的解释。

简单的解决方案是根本不专门化函数模板，而只是为特殊类型添加新的重载：

// no template, just a normal function
void foo(int*) {
    std::cout << "foo(int*)" << std::endl;
}

Answer 2

对于函数模板特化，您可以显式列出模板参数，但如果模板参数是推导得出的，则不必这样做。如果您不指定模板参数，编译器将使用与重载解析相同的规则来推导它们。为了决定选择哪个函数重载，编译器首先仅查看主模板（首先由一些神奇的过程选择）。查看两个可用的主模板，

template <typename T> void foo(T);
template <typename T> void foo(T*);

后者更适合指针参数。一旦找到正确的主模板，编译器就会查找该主模板的潜在特化。但是，您的示例#2 实际上并不是采用指针参数的函数模板的特化，尽管它涉及指针参数。如果您采用主声明

template <typename T> void foo(T*);

并将 T 替换为显式指定的模板参数 int*，您会得到

template <> void foo<int*>(int**);

也就是说，声明

template <> void foo<int*>(int*);

是不同的。您可能只想在指定模板参数时丢失指针：

template <> void foo<int>(int*);

Answer 3

我无法真正判断哪个函数 #2 应该专门化，或者确切地说极其复杂的重载解析规则将如何选择要调用的函数。

我确实知道您通常不需要专门化函数，而是可以依靠重载。要获得 int* 的函数，您只需要

void foo(int*) {
    std::cout << "foo(int*)" << std::endl;
}

只要参数匹配，非模板函数就会优先于模板。