Question

我刚读过这篇文章：Fun with C++ namespaces 作者在遇到第一个时会显示编译器停止查找重载，这里使用名称空间。

namespace A
{
   void f(int x); // like our std::sqrt(double)
}

namespace B
{
   struct S {}; // user-defined type with associated namespace B

   void f(S);
   void f(int, int);

   void test1()
   {
      using namespace A; // using DIRECTIVE
      f(1);              // ERROR  namespace A is not considered because
                         //        B contains two overloads for 'f'
      f(1,2);            // OK     B::f(int,int)
      f(B::S());         // OK     B::f(S)
   }   

   void test2()
   {
      using A::f; // using DECLARATION
      f(1);       // OK     A::f(int)
      f(1,2);     // ERROR  A::f  hides  B::f(int,int)
      f(B::S());  // OK     B::f(S) due to ADL!
   }
}

namespace C
{
   void test3()
   {
      using namespace A; // using DIRECTIVE
      f(1);              // OK     A::f(int)
      f(B::S());         // OK     B::f(S) due to ADL!
   }   

   void test4()
   {
      using A::f; // using DECLARATION
      f(1);       // OK     A::f(int)
      f(B::S());  // OK     B::f(S) due to ADL!
   }
}

为什么编译器应该停止？

编辑＃1：问题确实存在：为什么标准会这样说？

感谢所有答案！

Answer 1

编译器在遇到第一个
时停止查找重载

不，它在遇到第一个“时不会停止”，否则你找不到B::f(int,int)和B::f(S)。

它找到给定范围内的所有重载（不仅是第一个），但是在更远的范围内不会进一步查看。

这就像C ++中的所有名称查找一样，如果你有一个名为var的全局变量，并且在某些函数中你还有一个名为var的局部变量，使用函数中的名称将引用局部变量。这样更有用，你更有可能想要使用附近声明的变量，因为它在相关的代码中。

如果有人递给你一封信并告诉你把弗雷德放在几米远的地方，戴着一枚徽章上写着“我是弗雷德”，你会不会理睬他并走到外面继续寻找其他人在世界上叫弗雷德？

Answer 2

使用A :: f隐藏了＆＃34; f＆＃34;。

之前的所有定义

您可以使用

   void test2()
   {      
      f(1,2);     // ERROR  A::f  hides  B::f(int,int)
      using A::f; // using DECLARATION
      f(1);       // OK     A::f(int)
      f(B::S());  // OK     B::f(S) due to ADL!
   }

或

   void test2()
   {
      using A::f; // using DECLARATION
      f(1);       // OK     A::f(int)
      using B::f;
      f(1,2);     // ERROR  A::f  hides  B::f(int,int)
      f(B::S());  // OK     B::f(S) due to ADL!
   }

最佳做法是致电

   void test2()
   {
       A::f(1);       // OK     A::f(int)
       B::f(1,2);     // ERROR  A::f  hides  B::f(int,int)
       B::f(B::S());  // OK     B::f(S) due to ADL!
   }

明确提到使用了哪个功能

Answer 3

显而易见的答案是：因为标准是这样说的。原因标准说的是让你的程序更健壮：假设你写了你的课：

class MyClass : public SomeBase
{
private:
    void f( int );
    void g()
    {
        f( 'x' );
    }
};

就目前而言，在g的调用站点，编译器会找到 MyClass::f(int)，仅MyClass::f(int)。这是可能是你想要的。你不想要的是编译器如果有人碰巧，突然开始寻找SomeBase::f(char) 添加它。（所以，至少，理由是。）

最后：编译器不会总是停止查看它找到一个符号。例如，要考虑ADL。并且模板中的规则略有不同，具体取决于符号是否依赖。

为什么编译器会在重载时停止名称查找？

3 个答案: