关于重载解析的奇怪编译错误

Question

这段代码片段：

namespace ns
{
    struct last;

    struct first
    {
        typedef last next;
    };

    template <typename T>
    struct chain
    {
        chain<typename T::next> next;
    };

    template <>
    struct chain<last>
    {
    };
}

using namespace ns;

template <typename T>
void f(const T& x)          // #1
{
    f(x.next);
}

void f(const chain<last>&)  // #2
{
}

int main()
{
    f(chain<first>());
}

在 Comeau 上给出以下错误，在 GCC 上给出一个非常相似的错误：

"ComeauTest.c", line 27: error: class "ns::chain<ns::last>" has no member "next"
    f(x.next);
        ^
          detected during:
            instantiation of "void f(const T &) [with T=ns::chain<ns::last>]"
                      at line 27
            instantiation of "void f(const T &) [with T=ns::chain<ns::first>]"
                      at line 36

但是，如果 #2 定义在 #1 之前，或者 last 在 ns 之外声明，则它会编译。

对此有何解释？

Answer 1

给定

template <typename T>
void f(const T& x)          // #1
{
    f(x.next);
}

void f(const chain<last>&)  // #2
{
}

...在第一个正文中对f 的调用永远无法调用第二个f，因为此时第二个f 不可见。

所以如果你进入第一个f，那么它将递归到第一个错误。 :-) 我在这里谈论的是编译时递归，只要 next 属于 f 尚未实例化的类型。

还有main的电话，...

int main()
{
    f(chain<first>());
}

...必须调用第一个f，因为chain<first> 与第二个f 的参数类型不匹配。

这会导致递归调用 f( arg 类型为 chain<last> )。当尝试为参数类型chain<last> 实例化f 时，会出现错误，因为chain<last> 中没有next 属性。

关于在全局命名空间中放置last 的声明时显然编译好的代码，我不知道。你确定吗？注意：我没有用真正的编译器尝试过这些。

干杯，

Answer 2

案例一）

template <typename T>
void f(const T& x)          // #1
{
    f(x.next); //where's f ??
}

void f(const chain<last>&)  // #2
{
}

您需要通过在void f(const chain<last>&) // #2 上方指定template<> 来确保#2 是#1 的模板特化

没有template<> void f(const chain<last>&) 将被解释为f 的重载。因此，由于缺少 void f(const chain<last>&) 的声明，对 f(x.next); 的调用将是错误的。

在函数模板上方添加重载声明将使您的代码编译。

解决方案：

1)

template <typename T>
void f(const T& x)          // #1
{
    f(x.next); //hmm specialized version down there.
}

template<>
void f(const chain<last>&)  // #2
{
}

2)

void f(const chain<last>&); // #0

template <typename T>
void f(const T& x)          // #1
{
    f(x.next); //hmm I can see #0, call #2
}

void f(const chain<last>&)  // #2
{
}

---

案例 2)

void f(const chain<last>&)  // #2
{
}

template <typename T>
void f(const T& x)          // #1
{
    f(x.next); // found!!
}