C++ 名称查找机制：ADL 和两阶段模板查找

C++ 编译器如何解开名称的纠缠：ADL、模板和两阶段查找

名称查找是 C++ 编译过程中最复杂的阶段之一。由于语言的历史演变，查找规则变得错综复杂，即使是经验丰富的开发者也会遇到意外错误。让我们来分解查找机制的工作原理，以及为什么不同编译器行为不同。

关键术语：编译器如何分类名称

编译器使用精确的术语来分析代码中的名称。理解这些术语是解开查找“魔力”的关键。

非限定标识符 (unqualified-id) —— 名称的基本形式，例如 speed、foo 或 my_var。这还包括运算符、析构函数和用户定义字面量。示例：

// Nekvalifitsirovannye names
vector<int> v;       // 'vector' — unqualified name
sort(v.begin(), v.end()); // 'sort' — unqualified name

限定名称 (qualified-id) —— 使用作用域解析运算符 :: 的名称，例如 std::vector 或 Foo::bar。这里 Foo 作为限定符，bar 作为终端名称。

// Kvalifitsirovannye names
std::vector<int> v;  // 'vector' — qualified name
Foo::bar();          // 'bar' — terminal qualified name

模板 ID (template-id) —— 带有显式参数的模板名称，例如 std::vector<int>。

// Template-id
std::vector<int> v1;         // 'vector<int>' — template-id
std::pair<int, float> p;     // 'pair<int, float>' — template-id

终端名称 —— 编译器搜索的链式中的最终名称。例如，在 obj->f() 中终端名称是 f，在 ns::Foo::bar() 中是 bar。这在模板中尤为重要：

template<typename T>
void wrapper(T& obj) {
    obj.size();      // 'size' — terminal name
    T::value_type x; // 'value_type' — terminal qualified name
}

ADL：参数决定一切的时候

参数依赖查找 (ADL) 是一种机制，它会根据参数类型自动扩展函数搜索范围。没有 ADL，使用用户定义类型的重载运算符会变得很麻烦。

考虑这个示例：

namespace sak {
    struct BigNum { int value; };
    std::ostream& operator<<(std::ostream& os, const BigNum& n) {
        return os << "BigNum(" << n.value << ")";
    }
}

int main() {
    sak::BigNum n(42);
    std::cout << n; // ADL nakhodit operator<< in sak
}

编译器看到 n 的类型是 sak::BigNum，于是将 sak 命名空间添加到 operator<< 的搜索范围中。没有 ADL，你就得写成 sak::operator<<(std::cout, n)。

ADL 由 Andrew Koenig 在 1995 年提出（文档 N0645），尽管这个想法早在 AT&T Bell Labs 就已使用。标准在 [basic.lookup.koenig] 中将其规范化。然而，ADL 有陷阱：过度依赖它可能导致冲突，如果两个库在不同命名空间中定义同名函数。

ADL 算法：

• 执行普通非限定查找。
• 对于函数调用，ADL 启动：将参数类型的命名空间添加到搜索中。
• 如果名称是限定的（例如 std::sort），则不应用 ADL。

模板中的两阶段查找：为什么 GCC 和 Clang 意见不合

在模板中，名称查找分为两个阶段：

• 阶段 1（模板定义时）：搜索非依赖名称（独立于模板参数）。
• 阶段 2（实例化时）：搜索依赖名称（依赖于模板参数），此时应用 ADL。

历史上，不同编译器对这些规则的解释不同。GCC 7 版本之前使用“懒解析”：模板主体在定义时不分析，所有名称都在实例化时查找。这导致不符合标准。

分歧示例：

void foo(int) {}  // globalnaya foo

template<typename T>
void bar(T x) {
    foo(x);   // zavisimoe name — ischetsya in phase 2 (ADL), vsyo correct
    foo(42);  // NEzavisimoe name — must iskatsya in phase 1
}

namespace myns {
    struct MyType {};
    void foo(MyType) {}
}

bar(myns::MyType{}); // GCC: kompiliruetsya, Clang: oshibka

在 Clang 中，foo(42) 在阶段 1 查找，没有合适的过载（全局 foo(int) 不匹配 MyType），因此报错。GCC 则延迟到实例化时查找，并找到 foo(int)。

标准委员会禁止在阶段 1 中对依赖基类进行查找。考虑这个示例：

template<typename T>
struct Base {};

template<>
struct Base<int> {
    void process() {}
};

template<typename T>
struct Derived : Base<T> {
    void run() {
        process(); // Error: poszukiwanie in zavisimoy baze zapreschyon in phase 1
    }
};

如果在阶段 1 允许对 Base<T> 查找，该代码对于 T=int 会编译通过，但对于 T=float 则不会。这会破坏模板的可预测性。

关键要点：需要记住的事项

在处理 C++ 中的名称查找时，请牢记以下几点：

• 终端名称是编译器的焦点。识别它，就能知道在哪里查找。
• ADL 将查找扩展到参数命名空间。对运算符很棒，但可能引起冲突。
• 在模板中，非依赖名称在定义时查找，依赖名称在实例化时查找。依赖类型使用 typename。
• 不同编译器可能对边缘情况处理不同。在 GCC、Clang 和 MSVC 中测试。
• 对于依赖基类，使用 this-> 或作用域显式限定名称。

— Editorial Team