命名空间内的模板特化

Question

当这种奇怪的行为发生时，我正在处理一些代码：

在第一个测试中，基本模板函数、用户和模板特化位于同一个命名空间中，并且它的行为与我预期的一样：

    namespace Test1
    {
        template <typename V, typename T>
        int doFoo(V& a_visitor, T& a_value)
        {
            return 0;
        }

        struct Foo
        {
            template <typename T>
            int process(T const& a_value)
            {
                return doFoo(*this, a_value);
            }
        };

        template <typename T>
        int doFoo(Foo& a_vis, T const& a_ptr)
        {
            return 1;
        }
    }

    int main()
    {
        int const k{ 42 };

        return Test1::Foo{}.process(k); // returns 1
    }

但是当我将基本模板化函数及其特化移到另一个命名空间中时，会选择基本函数：

namespace Test2
{
    namespace b
    {
        template <typename V, typename T>
        int doBar(V& a_visitor, T& a_value)
        {
            return 0;
        }
    }

    struct Bar
    {
        template <typename T>
        int process(T const& a_value)
        {
            return b::doBar(*this, a_value);
        }
    };

    namespace b
    {
        template <typename T>
        int doBar(Bar& a_vis, T const& a_ptr)
        {
            return 1;
        }
    }
}

int main()
{
    int const k{ 17 };

    return Test2::Bar{}.process(k); // returns 0
}

编辑我可以做的更奇怪：在示例 1 中，如果我用 Test1::doFoo 替换对 doFoo 的调用，我会再次遇到错误的行为！

谁能解释一下这里发生了什么？如果我真的需要 struct Bar 不在命名空间 b 内，我该怎么办？

Answer 1

首先，这些不是特化，而是重载。完全不同且互不相关的函数模板。

您看到的行为与argument-dependent lookup 一致。当遇到不合格函数调用时，编译器通过检查与函数调用的每个参数关联的命名空间来构建重载集。

通常这不会在“之后”找到声明，但模板是特殊的。在模板中查找依赖名称，例如依赖于模板参数（a_value 的类型）的函数调用，是在模板实例化后执行的，而不是在定义点。这发生在main，在命名空间完成并且所有重载都可用之后，ADL 找到第二个重载。

这也是为什么当您通过Test1 限定调用时，您不再发现第二个重载。这否定了 ADL，并且只允许出现在调用点之前的重载。解决它的最简单方法可能是延迟 process 的定义，直到所有重载都可用，正如其他答案所示。