在模板中执行参数相关名称查找时的奇怪行为

Question

最近我正在研究著名的“两阶段名称查找”对模板类中名称的确切含义。尽管我已经阅读了很多关于这方面的文章，但我仍然无法了解这方面的一切。现在我对下面显示的代码感到困惑：

template<typename T>
class A
{
public:
    void f(T, T){};
};

namespace ns
{
    typedef int TT;
    void f(int, int){};
};

template<typename T>
class B : public A<T>
{
public:
    void g()
    {

        //f(T(), T()); // it's fine for error here
        typedef ns::TT TTT;
        f(TTT(), T()); // why this issued an error?
        f(ns::TT(), T()); // and this?
    }
};

/* I also think it's OK to move ns here */
// namespace ns
// {
//  typedef int TT;
//  void f(int, int){};
//};

int main()
{
    B<int> b;
    b.g();
}

请注意第二条评论。由于“f”是一个依赖名称，它的查找应该延迟到“main”函数中的实例化。那时，编译器应该在主函数的范围内执行参数依赖名称查找。我认为现在它应该发现命名空间 ns 中的函数，但它仍然发出编译错误：

1.cpp: In instantiation of 'void B<T>::g() [with T = int]':
1.cpp:30:6:   required from here
1.cpp:23:15: error: 'f' was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation [-fpermissive]    f(TTT(), T()); //why this issued an error?
               ^
1.cpp:23:15: note: declarations in dependent base 'A<int>' are not found by unqualified lookup
1.cpp:23:15: note: use 'this->f' instead

有人可以向我解释一下吗？谢谢。

Answer 1

依赖于参数的查找仅搜索参数类型的关联类和命名空间。 typedef 只是一个透明的别名，类似于 using 声明。

来自标准草案 n3485，[basic.lookup.argdep]/2 关于参数相关查找：

对于函数调用中的每个参数类型T，有一组零个或多个关联的命名空间和一组零个或多个关联的类需要考虑。命名空间和类的集合完全由函数参数的类型（以及任何模板模板参数的命名空间）决定。 用于指定类型的 Typedef 名称和 using-declarations 不构成此集合。

[强调我的]

---

template<typename T>
class A
{
public:
    void f(T, T){};
};

namespace ns
{
    typedef int TT;
    void f(int, int){};
};

template<typename T>
class B : public A<T> // note the base class is dependent
{
public:
    void g()
    {
        //f(T(), T()); // it's fine for error here
        typedef ns::TT TTT;
        f(TTT(), T()); // why this issued an error?
        f(ns::TT(), T()); // and this?
    }
};

由于基类是依赖的，因此在非限定查找期间不会对其进行搜索。因此，f 可以使用参数相关查找找到。您正确地指出，f 只会在“第二阶段”（在实例化点）被搜索，因为在您的调用中，至少一个参数取决于模板参数。

但是，ns 和 TT（在 ns::TT 中）不是从属名称。因此，命名空间和TT必须在用于g的定义之前声明。

无论您写f(ns::TT(), T()) 还是f(T(), T()) 都不会影响在依赖于参数的查找期间搜索f 的一般规则：仅关联的命名空间和参数类型的类（T 和@ 987654335@)。两者都是ints for B<int>::g()，因此没有关联的类和命名空间。

f(TTT(), TTT()) 更改查找，因为 f 现在是在名字查找阶段查找（它不是从属名称）。

---

这是一个依赖于参数的查找示例：

namespace ns
{
    struct TT {};
    void f(TT, TT) {}
}

int main()
{
    ns::TT x;
    f(x, x);
}

现在，您也可以在类模板的成员函数中执行此操作：

namespace ns
{
    struct TT {};
    void f(TT, TT) {}
}

template<typename T>
struct B
{
    void g()
    {
        f(T(), T());
    }
};

int main()
{
    B<ns::TT> x;
    x.g();
}

但是，正如我所说，依赖于参数的名称查找不适用于基本类型，例如 int。

在上面的示例中，f 再次依赖，因为至少有一个参数依赖于模板参数。因此，你也可以这样写：

template<typename T>
struct B
{
    void g()
    {
        f(T(), T()); // looked up during the second phase,
                     // from the point of instantiation
    }
};

namespace ns
{
    struct TT {};
    void f(TT, TT) {}
}

int main()
{
    B<ns::TT> x;
    x.g();
}