C++ ADL何时应用？

有3个例子：

一,

二,

三,

---

我不清楚ADL查找的实际条件是什么？我需要参考标准来描述它。

本标准段落澄清了这一点，甚至有一个与您的第一个示例非常相似的示例

3.4.1/3：

3.4.2[basic.lookup.argdep]中描述了对用作函数调用后缀表达式的非限定名称的查找。[注意：为了确定（在解析过程中）表达式是否是函数调用的后缀表达式，通常的名称查找规则适用。3.4.2中的规则对表达式的语法解释没有影响。例如

因为表达式不是函数调用，所以依赖于参数的名称查找（3.4.2）不适用，并且找不到友元函数

f

。-结束说明]

---

您的第一个示例没有说明ADL。排队

int t=foo(B::S());

foo

是

typedef

ed到

int

下面的代码有一些更好的ADL说明

#include <iostream>

namespace B
{
    struct S
    {
        operator int(){ return 24; }
    };

    int foo(S s){ return 100; }
    int bar(S s){ return 400; }
}

namespace C
{
    struct S
    {
        operator int(){ return 24; }
    };

    int foo(S s){ return 200; }
}

int bar(C::S s){ return 800; }

int main()
{
    // ADL makes it possible for foo to be resolved to B::foo
    std::cout << foo(B::S()) << std::endl;

    // ADL makes it possible for foo to be resolved to C::foo
    std::cout << foo(C::S()) << std::endl;

    // ADL makes it possible for bar to be resolved to B::bar
    std::cout << bar(B::S()) << std::endl;

    // ADL makes it possible for bar to be resolved to ::bar
    std::cout << bar(C::S()) << std::endl;
}

#包括
命名空间B
{
结构
{
运算符int（）{return 24；}
};
int foo（S）{return 100；}
整型条{return 400；}
}
命名空间C
{
结构
{
运算符int（）{return 24；}
};
int foo（S）{return 200；}
}
int-bar（C:：S）{return 800；}
int main（）
{
//ADL使得foo可以解析为B：：foo
你没看见吗？
namespace B
{
    struct S
    {
        operator int(){ return 24; }
    };
        int foo(B::S s){ return 0; }
}
int foo(B::S s){ return 12; }

int main()
{
    int t=foo(B::S()); //error: call of overloaded ‘foo(B::S)’ is ambiguous
                       //ADL applies
}

typedef int f;
namespace N {
  struct A {
    friend void f(A &);
    operator int();
    void g(A a) {
      int i = f(a);    // f is the typedef, not the friend
                       // function: equivalent to int(a)
    }
  };
}

int t=foo(B::S());

#include <iostream>

namespace B
{
    struct S
    {
        operator int(){ return 24; }
    };

    int foo(S s){ return 100; }
    int bar(S s){ return 400; }
}

namespace C
{
    struct S
    {
        operator int(){ return 24; }
    };

    int foo(S s){ return 200; }
}

int bar(C::S s){ return 800; }

int main()
{
    // ADL makes it possible for foo to be resolved to B::foo
    std::cout << foo(B::S()) << std::endl;

    // ADL makes it possible for foo to be resolved to C::foo
    std::cout << foo(C::S()) << std::endl;

    // ADL makes it possible for bar to be resolved to B::bar
    std::cout << bar(B::S()) << std::endl;

    // ADL makes it possible for bar to be resolved to ::bar
    std::cout << bar(C::S()) << std::endl;
}