ADL如何影响这段C代码？

Question

实际上，下面的代码不能用这个命令用Clang编译：

clang-std=c 11test.cc-o test.

我只想模仿与C中的“交换习惯用法”相同的行为，使用“using directive”来启用ADL。但是下面的代码哪里错了呢？预期的调用优先级应为：N1：：foo

namespace N1 {
  struct S {};
  void foo(S s) {
    std::cout << "called N1::foo.";
  }
}
namespace N2 {
  void foo(N1::S s) {
    std::cout << "called N2::foo.";
  }
}
void foo(N1::S s) {
  std::cout << "called foo.";
}
int main() {
  using N2::foo;  
  foo(N1::S{});
}

错误消息：

test.cc:54:3: error: call to 'foo' is ambiguous
  foo(N1::S{});
  ^~~
test.cc:40:8: note: candidate function
  void foo(S s) {
       ^
test.cc:45:8: note: candidate function
  void foo(N1::S s) {
       ^
1 error generated.

更新：

我将N2::foo更改为可以在某种程度上模仿std::交换的模板方法。所以，这里的问题是为什么::foo不能由foo（N1::S{}）调用；在main函数中？因为当它们具有相同的优先级时，该函数应该比要调用的模板函数更合适。

namespace N1 {
  struct S {};
  /*
  void foo(S s) {
    std::cout << "called N1::foo, specific one." << '\n';
  }
  */
}
namespace N2 {  // as a fallback to unqualified name which has no user-defined overload.
  template<typename T>
  void foo(T) {
    std::cout << "called N2::foo, generic one." << '\n';
  }
}
void foo(N1::S s) {
  std::cout << "called foo." << '\n';
}
int main() {
  using N2::foo;
  foo(N1::S{});
  foo(10);  // use generic version.
}

Answer 1

首先，您有一个普通的查找，它从内部作用域到外部作用域进行搜索，并在第一次匹配时停止，从后面的作用域隐藏重载。然后，当触发ADL时，它将向搜索中添加其他关联实体和名称空间。

因此，在您的情况下，ADL查找不会向重载集添加任何内容。

#include <iostream>

namespace N1 {
  struct S {};
  /*
  void foo(S s) {
    std::cout << "called N1::foo, specific one." << '\n';
  }
  */
}
namespace N2 { 
  template<typename T>
  void foo(T) {
    std::cout << "called N2::foo, generic one." << '\n';
  }
}
void foo(N1::S s) {
  std::cout << "called foo." << '\n';
}
int main() {
  using N2::foo;
  foo(N1::S{}); // ordinary lookup finds N2 in main scope and stops.
                // adl lookup add N1 ns to the additionnal ns set but finds nothing
                // overload set = N2::foo by ordinary lookup
}

现在，如果我取消注释您的S1版本，它就赢了！这就是你得到的：

#include <iostream>

namespace N1 {
  struct S {};
  void foo(S s) {
    std::cout << "called N1::foo, specific one." << '\n';
  }
}
namespace N2 { 
  template<typename T>
  void foo(T) {
    std::cout << "called N2::foo, generic one." << '\n';
  }
}
void foo(N1::S s) {
  std::cout << "called foo." << '\n';
}
int main() {
  using N2::foo;
  foo(N1::S{}); // ordinary lookup finds N2 in main scope and stops
                // adl lookup add N1 ns to the additionnal ns set and finds N1::foo
                // overload set = N2::foo by ordinary lookup, N1::foo by ADL, N1::foo wins
}

交换也会得到同样的结果。在本例中，使用Foo：：swap是因为它位于N1命名空间中：

#include <iostream>

namespace N1 {
    struct Foo {

    };
    void swap(Foo& , Foo&) {
        std::cout << "swap Foo" << std::endl;
    }
}

namespace N2 {

struct S {
    N1::Foo f;
};

void swap(S& l,S& r) {
    using std::swap; // overload set is std::swap by ordinary lookup
    swap(l.f, r.f); // and Foo::swap by ADL, Foo::swap wins
}
}

int main() {
    N2::S s1,s2;
    swap(s1,s2);
}

但是，如果在全局ns中移动特定于Foo的交换，则调用：

#include <iostream>

namespace N1 {
    struct Foo {

    };
}

void swap(N1::Foo& , N1::Foo&) {
    std::cout << "swap Foo" << std::endl;
}

namespace N2 {

struct S {
    N1::Foo f;
};

void swap(S& l,S& r) {
    using std::swap; // overload set is std::swap by ordinary lookup
    swap(l.f, r.f); // because ADL does not add the global ns to the
                    // ns to be searched for
}
}

int main() {
    N2::S s1,s2;
    swap(s1,s2);
}

Answer 2

在这种情况下，普通名称查找找到N2::foo，ADL找到N1::foo，它们都被添加到重载集中，然后执行重载解析并且调用不明确。

顺便说一句：如果没有使用N2::foo；在main（）中，::foo将通过正常名称查找找到，并且N1::foo也被ADL找到；因此调用仍然是模棱两可的。

更新：

因此，这里的问题是为什么主函数中的“foo（N1：：S{}）；”不能调用：：foo？

因为随着使用N2::foo；的的使用，名称N2::foo被引入main函数中。当调用foo时，名称N2::foo将在main的范围内找到，然后名称查找停止，进一步的范围（全局命名空间）将不会被检查，因此::foo根本不会被找到并添加到重载集中。结果N2::foo都被调用。

名称查找如下所述检查范围，直到它找到至少一个任何类型的声明，此时查找停止并且不再检查其他范围。

顺便说一句：如果您将使用N2::foo；放在全局命名空间中main之前，foo（N1::S{}）；将调用::foo。N2::foo和::foo都可以通过名称查找找到，并且::foo在重载解析中获胜。

现场直播