c++模板规范和重载的解析

Question

我已经阅读了Why Not Specialize Function Templates 并在进行了一些实验之后， 我发现了一件有趣的事情。这是main.cxx：

// main.cxx
#include <iostream>

// Declarations
/*
template<class T>
void foo(T);

template<>
void foo(int*);

template<class T>
void foo(T*);
*/

// Definition and specification
template<class T>
void foo(T x)
{
    std::cout << "T version." << std::endl;
}

template<>
void foo(int *i)
{
    std::cout << "int* version." << std::endl;
}

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

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

有趣的是：如果我将声明部分保留为注释，则行为就像文章所说的那样，即如果 int* 版本的定义在其定义之前，则将使用 T* 版本，反之亦然。但是，如果取消注释声明块，无论我在定义或声明中使用哪种顺序，都只会调用 int* 版本。我的问题是该声明如何影响决议？

有什么想法吗？我在 x86_64-redhat-linux 上使用 g++ 4.2.2

编辑：在看到 AProgrammer 的回答后简化这个问题

Answer 1

将源代码分发到三个文件中只会混淆问题：预处理使编译单元成为一个编译单元，其行为仅取决于 CU 的内容，而不是分发的文件数量。

我认为你对这种情况感到惊讶

#include <iostream>

template<class T> void foo(T); // A
template<> void foo(int*); // 1
template<class T> void foo(T*); // B

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

template<> void foo(int *i) // 2
{ std::cout << "int* version." << std::endl; }

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

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

你会得到int* version。这是预期的行为。虽然 (1) 确实声明了 template <typename T> void foo(T) 的特化，但 (2) 不是该特化的定义。 (2) 定义并声明template<class T> void foo(T*); 的特化，然后在main() 中调用它。如果您在放置声明和定义的任何内容中给出三个定义之前的三个声明，则会发生这种情况。定义 (2) 将始终看到声明 template<class T> void foo(T*);，因此是它的特化。

当一个函数模板的特化被声明或定义并且它可以是多个函数模板的特化（如这里（2）可以是两个重载A和B的特化，它们只需要被声明），它是“更专业”的专业化。您可以在标准部分 17.5.5.2 中看到“更专业化”的精确定义，但很容易看出，对于 (2)，B 比 A 更匹配，因此 (2) 是 (B) 的专业化. (1) 声明 (A) 的特化，因为当声明 (1) 时，还没有看到 (B)。如果你想在看到（B）之后给出（1）的定义，你必须写

template <> void foo<int*>(int*) // definition for (1)
{ std::cout << "foo<int*>(int*)\n"; }

定义 (2) 时也可以是显式的：

template<> void foo<int>(int *i) // 2 alternate
{ std::cout << "int* version." << std::endl; }

（但显然给 (2) 和同一个 CU 中的这个替代版本会给你一个错误）。

调用函数时也可以显式：

foo(p); // call (2)
foo<int>(p); // call (2)
foo<int*>(p); // call (1)