在命名空间中使用自己的 class 比较 std::vector 不编译

Question

以下代码无法编译，因为未找到比较运算符。

#include <vector>
#include <iostream>
#include <string>

namespace Cool {
    struct Person {
        std::string name;
    };
}

bool operator==(const Cool::Person&  p1, const Cool::Person& p2) {
    return p1.name == p2.name;
}

int main(int, char *[])
{
    std::vector<Cool::Person> a{ {"test"} };
    std::vector<Cool::Person> b{ {"test"} };
    bool ok = a == b;
    std::cout << ok << std::endl;
}

经过一些实验，我发现以下代码可以完美编译：

#include <vector>
#include <iostream>
#include <string>

namespace Cool {
    struct Person {
        std::string name;
    };

    bool operator==(const Person&  p1, const Person& p2) {
        return p1.name == p2.name;
    }
}

int main(int, char *[])
{
    std::vector<Cool::Person> a{ {"test"} };
    std::vector<Cool::Person> b{ {"test"} };
    bool ok = a == b;
    std::cout << ok << std::endl;
}

有人可以解释这种行为背后的基本原理吗？

Answer 1

这称为 ADL，或参数相关查找。

对于运算符，编译器不仅会在当前命名空间中搜索合适的函数，还会在参数的命名空间中搜索。

例如：

int main() {
    int arr[3] = {};
    std::vector<int> vec(3);

    auto b_vec = begin(vec); // std::begin
    auto b_arr = begin(arr); // Error!
}

当使用 vec 调用 begin 时，它将在 std 命名空间中搜索，因为 std::vector 在该命名空间中。对于原始数组，找不到该函数，因为它没有与该类型关联的名称空间。

关闭 ADL 的一种方法是简单地限定函数：

// calls the std:: one, not the boost:: one
std::begin(some_boost_container);

这也是朋友功能的工作原理：

struct test {
    friend void find_me(int) {}
};

find_me(3); // uh? no matching function?

虽然功能很好，但是找不到。

它的参数中需要 class 的名称，以便 ADL 启动并在 class 范围内找到它：

struct test {
    friend void find_me(test const&) {}
};

find_me(test{}); // works!

所以...对于运营商？为什么有效？

因为调用用户定义的运算符大致等同于：

// arg1 == arg2;
operator==(arg1, arg2);

由于函数名不合格，ADL开始。然后在正确的命名空间中找到运算符，也可以找到友元函数。

这既允许良好的语法，也允许通用函数调用您的命名空间内的函数。

那么为什么向量找不到全局命名空间中的那个？

这是因为 ADL 的工作原理。在带有名称的函数的命名空间内，ADL 将仅在参数的命名空间内搜索。但如果找不到，它将回退到正常查找。

namespace Cool {
    struct Person {
        std::string name;
    };
}

bool cant_you_find_me(Cool::Person const& p);

namespace test {
    void cant_you_find_me();

    template<typename T>
    void test_template(T const& p) {
        cant_you_find_me(p); // ADL?
    }
}

在此示例中，ADL 将搜索一个函数 cant_you_find_me，但如果无法通过 ADL 找到一个函数，则不会考虑全局命名空间，因为正常查找将找到最接近的函数：正在使用的函数没有争论。

这就是 std 命名空间所发生的情况。里面定义了很多operator==。如果 ADL 没有找到合适的，则不会考虑全局命名空间，而是考虑 std 中的那些。

在命名空间中使用自己的 class 比较 std::vector 不编译

Comparing std::vector using own class in namespace does not compile

c++

stl

namespaces

operator-overloading

stdvector