unordered_map 迭代器比较中的意外错误

Question

我有一个简单的地图 std::map，我使用的是 c++11，所以出于性能原因，我将其替换为 unordered_map。将迭代器与 end() 进行比较时出现以下错误。

auto cit = str_map_.find(str);
if (cit != str_map_.end()) {
   ...
}

在 'bool my_namespace::operator!=(const T1&, const T2&) 的实例化中 [with T1 = std::__detail::_Node_iterator<:pair std::__cxx11::basic_string my_namespace::>； T2 = std::__detail::_Node_iterator<:pair std::__cxx11::basic_string my_namespace::mytype false true>]'：没有匹配的函数...

我将它调试到我相当有创意的比较运算符 my_namespace::MyType:

template <class T>
struct MyType {
    T* mt_;
};

struct MyTempClass {
    std::string mtc_;

    static int Compare(MyType<MyTempClass> const& lhs, MyType<MyTempClass> const& rhs) {
        return lhs.mt_->mtc_.compare(rhs.mt_->mtc_);
    }

    static int Compare(std::string const& lhs, MyType<MyTempClass> const& rhs) {
        return lhs.compare(rhs.mt_->mtc_);
    }

    static int Compare(MyType<MyTempClass> const& lhs, std::string const& rhs) {
        return lhs.mt_->mtc_.compare(rhs);
    }
};

template <class T1, class T2>
bool operator !=(T1 const& lhs, T2 const& rhs) {
    int res = MyTempClass::Compare(lhs, rhs);
    return (res != 0);
}

template <class T1, class T2>
bool operator ==(T1 const& lhs, T2 const& rhs) {
    int res = MyTempClass::Compare(lhs, rhs);
    return (res != 0);
}

static std::unordered_map<std::string, MyType<MyTempClass>> my_map;

但我仍然不明白为什么会发生这种情况：相同的代码在普通地图上也能正常工作，而值类型不应该参与迭代器比较？

Answer 1

您定义了一个将任何类型作为参数的operator!= 重载。该重载与MyType 类型位于同一命名空间中。因此，可以通过 ADL 找到它。

如错误消息所示，标准库使用的 std::unordered_map 迭代器是类模板特化，专门针对 std::unordered_map 模板参数。因此，当您将迭代器与!= 进行比较时，将对参数执行 ADL，并且 ADL 搜索的命名空间还包括参数类型的类型模板参数的命名空间。因此，您在MyType 命名空间中的operator!= 重载也会被找到并参与重载解析。

假设您使用 libstdc++ 作为基于错误消息的标准库实现，您可以查看 it's implementation 的 operator!= 的哈希表迭代器，您将看到它使用这些迭代器的基类，并为基类对象的引用定义比较运算符。

因此，迭代器比较的标准重载需要在其参数中进行派生到基引用的转换，而您的重载则不需要。

因此，您的重载更好，将被选择进行cit != str_map_.end() 比较。您的重载尝试传递参数 MyTempClass::Compare 显然不起作用，因为这些函数不期望 std::unordered_map 迭代器。

---

解决方案不是为不依赖于用户定义类型的类型对重载运算符。将重载限制为您自己的类型：

template <class T1, class T2>
bool operator !=(MyType<T1> const& lhs, T2 const& rhs) {
    int res = MyTempClass::Compare(lhs, rhs);
    return (res != 0);
}

template <class T1, class T2>
bool operator !=(T1 const& lhs, MyType<T2> const& rhs) {
    int res = MyTempClass::Compare(lhs, rhs);
    return (res != 0);
}

（相当于operator==）。

---

据我所知，不禁止重载标准库类型对的运算符，但我也不认为标准库需要解决在您的代码中产生的冲突。

使用std::map，标准库实现可能选择了一种不同的方式来实现迭代器比较，这使得它更适合重载解决方案，或者通过不使迭代器成为专门针对键的模板来避免 ADL 发现您的重载/值类型。