Argument-dependent lookup

实参依赖查找（ADL），又称柯尼希查找 ^[1] ，是一组用于在 函数调用表达式 中查找非限定函数名的规则集，包括对 重载运算符 的隐式函数调用。除了常规 非限定名称查找 所考虑的作用域和命名空间外，这些函数名还会在其参数所属的命名空间中进行查找。

#include <iostream>
int main()
{
    std::cout << "Test\n"; // 全局命名空间中无 operator<<，但 ADL
                           // 会检查 std 命名空间，因为左实参属于
                           // std 命名空间，从而找到 std::operator<<(std::ostream&, const char*)
    operator<<(std::cout, "Test\n"); // 同上，使用函数调用表示法
    // 然而：
    std::cout << endl; // 错误：“endl”未在此命名空间声明
                       // 这不是对 endl() 的函数调用，故 ADL 不适用
    endl(std::cout); // 正确：此为函数调用，ADL 检查 std 命名空间
                     // 因为 endl 的实参属于 std，从而找到 std::endl
    (endl)(std::cout); // 错误：“endl”未在此命名空间声明
                       // 子表达式 (endl) 不是非限定标识符
}

详情

首先，若由常规 非限定查找 产生的查找集合包含以下任意元素，则不会进行实参依赖查找：

否则，对于函数调用表达式中的每个实参，将检查其类型以确定它将在查找过程中添加的 关联命名空间和类集合 。

在确定关联的类和命名空间集合后，该集合中类内发现的所有声明将在后续ADL处理过程中被舍弃，但如下文第2点所述，命名空间作用域的友元函数和函数模板除外。

通过常规 非限定查找 找到的声明集合，与通过ADL在关联集合的所有元素中找到的声明集合，将按照以下特殊规则进行合并：

注释

由于实参依赖查找，在类同一命名空间中定义的非成员函数和非成员运算符被视为该类公共接口的组成部分（若通过ADL查找到） ^[2] 。

ADL 是泛型代码中交换两个对象既定惯用法的原因： using std:: swap ; swap ( obj1, obj2 ) ; ，因为直接调用 std:: swap ( obj1, obj2 ) 不会考虑可能在 obj1 或 obj2 类型所在命名空间中定义的用户自定义 swap() 函数，而仅调用非限定版本的 swap ( obj1, obj2 ) 在未提供用户自定义重载时将无法调用任何函数。特别地， std::iter_swap 及所有其他标准库算法在处理 Swappable 类型时均采用此方法。

名称查找规则使得在全局或用户定义命名空间中声明作用于 std 命名空间类型的运算符变得不切实际，例如为 std::vector 或 std::pair 自定义 operator >> 或 operator + （除非 vector/pair 的元素类型是用户定义类型，这会将其命名空间加入 ADL）。此类运算符在模板实例化时不会被查找，例如标准库算法中。详见 依赖名 获取更多信息。

ADL 能够找到完全在类或类模板内部定义的 友元函数 （通常是重载运算符），即使该函数从未在命名空间级别进行过声明。

template<typename T>
struct number
{
    number(int);
    friend number gcd(number x, number y) { return 0; }; // 在类模板内部定义
                                                         // 的友元函数
};
// 除非提供匹配的声明，否则gcd是该命名空间中
// 不可见的成员（仅能通过ADL访问）
void g()
{
    number<double> a(3), b(4);
    a = gcd(a, b); // 因number<double>是关联类而找到gcd，
                   // 使其在其命名空间（全局作用域）中可见
//  b = gcd(3, 4); // 错误；gcd不可见
}

namespace N1
{
    struct S {};
    template<int X>
    void f(S);
}
namespace N2
{
    template<class T>
    void f(T t);
}
void g(N1::S s)
{
    f<3>(s);     // C++20前为语法错误（非限定查找找不到f）
    N1::f<3>(s); // 正确：限定查找找到模板'f'
    N2::f<3>(s); // 错误：N2::f不接受常量参数
                 //        N1::f未被查找，因为ADL仅对非限定名称生效
    using N2::f;
    f<3>(s); // 正确：非限定查找现在找到N2::f
             //     随后ADL因该名称为非限定而生效，并找到N1::f
}

在以下语境中仅发生 ADL 查找（即仅在关联命名空间中查找）：

• 从模板实例化点进行的 依赖名称查找 。

示例

namespace A
{
    struct X;
    struct Y;
    void f(int);
    void g(X);
}
namespace B
{
    void f(int i)
    {
        f(i); // 调用 B::f（无限递归）
    }
    void g(A::X x)
    {
        g(x); // 错误：在 B::g（普通查找）和 A::g（实参依赖查找）之间存在歧义
    }
    void h(A::Y y)
    {
        h(y); // 调用 B::h（无限递归）：ADL 检查了 A 命名空间
              // 但未找到 A::h，因此仅使用普通查找找到的 B::h
    }
}

缺陷报告

以下行为变更缺陷报告被追溯应用于先前发布的 C++ 标准。

参见

• 名称查找
• 模板实参推导
• 重载决议

外部链接