混淆函数查找与 C++ 中的模板

Question

从以下内容开始（使用gcc version 4.0.1）：

namespace name {
   template <typename T>
   void foo(const T& t) {
      bar(t);
   }

   template <typename T>
   void bar(const T& t) {
      baz(t);
   }

   void baz(int) {
      std::cout << "baz(int)\n";
   }
}

如果我添加（在global命名空间中），

struct test {};
void bar(const test&) {
   std::cout << "bar(const test&)\n";
}

那么，正如我所料，

name::foo(test()); // produces "bar(const test&)"

但如果我只是添加

void bar(const double&) {
   std::cout << "bar(const double&)\n";
}

它就可以'似乎没有找到这个重载：

name::foo(5.0) // produces "baz(int)"

更重要的是，

typedef std::vector<int> Vec;
void bar(const Vec&) {
   std::cout << "bar(const Vec&)\n";
}

也没有出现，因此

name::foo(Vec());

给出了编译器错误

error: cannot convert ‘const std::vector<int, std::allocator<int> >’ to ‘int’ for argument ‘1’ to ‘void name::baz(int)’

这是查找应该如何工作的吗？ （注意：如果我删除命名空间 name，那么一切都会按我的预期工作。）

如何修改此示例，以便考虑 bar 的任何重载？ （我认为重载应该在模板之前被考虑？）

Answer 1

我假设您也将 double 版本添加到全局命名空间，并且在定义所有内容后从 main 调用 foo 。所以这基本上是两个阶段的名称查找。查找因调用中的参数依赖（取决于其类型）而依赖的非限定函数名是分两个阶段完成的。

第一阶段在定义上下文中进行不合格且依赖于参数的查找。然后它冻结结果，并使用实例化上下文（实例化时声明的总和）仅进行第二个参数相关查找。 不再进行不合格的查找。因此，对于您的示例，这意味着：

• foo中的调用 bar(t) 使用参数相关查找来查找 bar实例化上下文（它没有使用非限定查找找到它，因为 foo 是在 bar 模板的上方声明的）。根据您在 foo 模板之前还是之后定义全局 bar ，它将使用依赖于参数的查找来查找全局 bar 声明第一阶段（它在 test 的命名空间中定义）。然后 main 中的调用将实例化 foo ，并且在此阶段可能会找到 bar （如果您在声明模板之后声明它）。

• foo 中的调用 bar(t) 不会执行依赖于参数的查找（或者更确切地说，查找的结果是一个空声明集） ，因为 int 是基本类型。因此，对定义上下文的非限定查找也不会找到任何内容，因为匹配的 bar 模板是在 foo 模板之后声明的。该调用的格式不正确，标准在 14.6.4.2/1

  中描述了这种情况

  <块引用>

  如果调用格式不正确[...]，则程序具有未定义的行为。

  因此，我认为您应该将其视为“我做了一件肮脏的事情，而编译器选择不打我”的情况：)

• foo< 中的调用 bar(t) Vec> 将再次进行查找，并在 std:: 中查找 bar（因为这是定义 std::vector 的地方）。它在那里找不到 bar，在定义上下文中也没有。因此，它决定再次采用未定义的行为，并使用 bar 模板，而该模板本身又通过使用其后声明的 baz 来执行未定义的行为，但无法找到该模板既不通过 ADL 也不通过定义上下文中的无限定查找。

  如果向量是一个 vector，那么对 bar 的查找也将在全局范围内完成，因为依赖于参数的查找将不仅使用参数类型直接，还有其中模板参数的类型（如果有）。

---

如果您使用 GCC，那么不要完全依赖它的行为。在下面的代码中，它声称调用是不明确的，尽管代码完全没问题 - afake 中的 f 不应该是候选者。

namespace aname {
  struct A { };
  void f(A) { }
}

namespace afake {
  template<typename T>
  void g(T t) { f(t); }
  void f(aname::A) { }
}

int main() { aname::A a; afake::g(a); }

如果您想测试代码片段的一致性，最好使用具有严格设置的 comeau 在线编译器。

Answer 2

我可以确认您在我的系统上看到的行为，并且我相信它是正确的。

看起来重载解析只是在其参数的命名空间中查找，因此采用 test 的 bar 版本可以工作，因为 test 位于全局命名空间，因此编译器会在那里检查 bar 的版本，正如您正确指出的那样，该版本优先于模板化版本。

对于 Vec 版本，重要的命名空间是 std。如果您将一个版本的 bar 放入 std 中，您会发现它会拾取它。

double 版本不起作用，因为全局命名空间不用于查找，因为 double 是内置类型，并且不以任何方式与全局命名空间专门关联。

Answer 3

在“c++ koenig Lookup”上进行谷歌搜索，

这应该可以为您提供有关模板查找规则的足够信息。

Herb Sutter 有一篇关于这个主题的好文章：
http://www.gotw.ca/gotw/030.htm

Answer 4

查找名称的规则是，如果名称不合格，则将使用参数的命名空间来搜索函数。

name::foo(test()); 之所以有效，是因为在 foo 中你基本上调用了 bar(test()); 并且 test 的命名空间是用于搜索栏。在本例中，是全局命名空间。

name::foo(Vec()); 这不会起作用，因为 Vec 是 typedef 而不是类或结构。

有关函数名称查找规则，请参阅 C++ 标准。

Answer 5

以下程序在 gcc 4.3 和 gcc 4.1（我手头上仅有的两个编译器）上运行良好

#include <iostream>
#include <vector>

namespace name {
   template <typename T>
   void foo(const T& t) {
      bar(t);
   }

   template <typename T>
   void bar(const T& t) {
      baz(t);
   }

   void baz(int) {
      std::cout << "baz(int)\n";
   }

   struct test {};
    void bar(const test&) {
       std::cout << "bar(const test&)\n";
    }

    void bar(const double&) {
       std::cout << "bar(const double&)\n";
    }

    typedef std::vector<int> Vec;
    void bar(const Vec&) {
       std::cout << "bar(const Vec&)\n";
    }
}

int main()
{
    name::foo(name::test());
    name::foo(5.0);
    name::foo(name::Vec());
}

：

bar(const test&)
栏（const double&）
条（常量 Vec&）

您使用什么编译器？

Answer 6

下面的代码对我来说使用 VS 2005 Professional Edition 编译得很好：

#include <iostream>
#include <vector>

using std::cout;


typedef std::vector<int> Vec;

namespace name {
    template <typename T>
    void foo(const T& t) {
        bar(t);
    }

    template <typename T>
    void bar(const T& t) {
        baz(t);
    }

    void baz(int) {
        std::cout << "baz(int)\n";
    }   

    void bar(const Vec&) {
        std::cout << "bar(const Vec&)\n";
    }
}


int main()
{
    name::foo(Vec());
    return 0;
}

请发布您的原始代码，以便我们找出问题所在。