如何使用带有用户定义类型的 std::maps 作为键？

Question

我想知道为什么我不能将 STL 映射与用户定义的类一起使用。 当我编译下面的代码时，我收到以下神秘的错误消息。 这是什么意思？ 另外，为什么它只发生在用户定义的类型上？ （原始类型用作键时是可以的。）

C:\\MinGW\\bin..\\lib\\gcc\\mingw32\\3.4.5........\\include\\c++\\3.4.5\\bits\\stl_function.h||在成员函数`bool std:: less<_Tp>::operator()(const _Tp&, const _Tp&) const [with _Tp = Class1]':|

C:\\MinGW\\bin..\\lib\\gcc\\mingw32\\3.4.5........\\include\\c++\\3.4.5\\bits\\stl_map.h|338|从`_Tp& std::实例化map<_Key, _Tp, _Compare, _Alloc>::operator[](const _Key&) [with _Key = Class1, _Tp = int, _Compare = std::less, _Alloc = std::allocator >]'|

C:\\Users\\Admin\\Documents\\dev\\sandbox\\sandbox\\sandbox.cpp|24|从这里实例化|

C:\\MinGW\\bin..\\lib\\gcc\\mingw32\\3.4.5........\\include\\c++\\3.4.5\\bits\\stl_function.h|227|错误：“运算符不匹配” <' 在'__x < __y'| ||=== 构建完成：1 个错误，0 个警告 ===|

#include <iostream>
#include <map>

using namespace std;

class Class1
{
public:
    Class1(int id);

private:
    int id;
};

Class1::Class1(int id): id(id)
{}

int main()
{
    Class1 c1(1);

    map< Class1 , int> c2int;
    c2int[c1] = 12;

    return 0;
}

Answer 1

你不必定义operator<为你的类，其实。 您还可以为它创建一个比较器函数对象类，并使用它来专门化std::map 。 扩展您的示例：

struct Class1Compare
{
   bool operator() (const Class1& lhs, const Class1& rhs) const
   {
       return lhs.id < rhs.id;
   }
};

std::map<Class1, int, Class1Compare> c2int;

碰巧std::map的第三个模板参数的默认值是std::less ，它将委托给为您的类定义的operator< （如果没有，则失败）。 但有时您希望对象可用作映射键，但实际上您没有任何有意义的比较语义，因此您不想通过在您的类上提供operator<来混淆人们。 如果是这种情况，您可以使用上述技巧。

实现相同目标的另一种方法是专门化std::less ：

namespace std
{
    template<> struct less<Class1>
    {
       bool operator() (const Class1& lhs, const Class1& rhs) const
       {
           return lhs.id < rhs.id;
       }
    };
}

这样做的好处是它会由std::map “默认”选择，但您不会以其他方式将operator<暴露给客户端代码。

Answer 2

默认情况下std::map （和std::set ）使用operator<来确定排序。 因此，您需要在您的类上定义operator< 。

if !(a < b) && !(b < a)两个对象被认为是等价的。

如果出于某种原因，您想使用不同的比较器，则可以将map的第三个模板参数更改为std::greater ，例如。

Answer 3

您需要为 Class1 定义operator < 。

Map 需要使用运算符 < 比较值，因此当用户定义的类用作键时，您需要提供相同的值。

class Class1
{
public:
    Class1(int id);

    bool operator <(const Class1& rhs) const
    {
        return id < rhs.id;
    }
private:
    int id;
};

Answer 4

class key
{
    int m_value;
public:
    bool operator<(const key& src)const
    {
        return (this->m_value < src.m_value);
    }

};
int main()
{
    key key1;
    key key2;
    map<key,int> mymap;
    mymap.insert(pair<key,int>(key1,100));
    mymap.insert(pair<key,int>(key2,200));
    map<key,int>::iterator iter=mymap.begin();
    for(;iter!=mymap.end();++iter)
    {
        cout<<iter->second<<endl;
    }


}

Answer 5

键必须具有可比性，但您尚未为自定义类定义合适的operator< 。

Answer 6

我想稍微扩展一下Pavel Minaev 的回答，您应该在阅读我的回答之前先阅读这些内容。 如果要比较的成员（例如问题代码中的id ）是私有的，Pavel 提出的两种解决方案都不会编译。 在这种情况下，VS2013 为我抛出以下错误：

错误 C2248：“Class1::id”：无法访问类“Class1”中声明的私有成员

正如SkyWalker在对Pavel回答的评论中所提到的，使用friend声明会有所帮助。 如果你想知道正确的语法，这里是：

class Class1
{
public:
    Class1(int id) : id(id) {}

private:
    int id;
    friend struct Class1Compare;      // Use this for Pavel's first solution.
    friend struct std::less<Class1>;  // Use this for Pavel's second solution.
};

Ideone 上的代码

但是，如果您有私有成员的访问函数，例如id getId() ，如下所示：

class Class1
{
public:
    Class1(int id) : id(id) {}
    int getId() const { return id; }

private:
    int id;
};

那么你可以用它代替friend声明（即你比较lhs.getId() < rhs.getId() ）。 从C++11 开始，您还可以将lambda 表达式用于Pavel 的第一个解决方案，而不是定义比较器函数对象类。 把所有的东西放在一起，代码可以写成如下：

auto comp = [](const Class1& lhs, const Class1& rhs){ return lhs.getId() < rhs.getId(); };
std::map<Class1, int, decltype(comp)> c2int(comp);

Ideone 上的代码

Answer 7

正确的解决方案是为您的类/结构专门化std::less 。

• 基本上cpp 中的映射是作为二叉搜索树实现的。

1. BST 比较节点的元素以确定树的组织。
2. 元素比较小于父节点的节点放在父节点的左边，元素比较大于父节点元素的节点放在右边。 IE

对于每个节点， node.left.key < node.key < node.right.key

BST 中的每个节点都包含元素，并且在映射的情况下其 KEY 和值，并且键应该是有序的。 更多关于地图实现：地图数据类型。

在 cpp 映射的情况下，键是节点的元素，值不参与树的组织，它只是一个补充数据。

所以这意味着键应该与std::less或operator<兼容，以便可以组织它们。 请检查地图参数。

否则，如果您使用用户定义的数据类型作为键，则需要为该数据类型提供完整的比较语义。

解决方案：专门化std::less ：

地图模板中的第三个参数是可选的，它是std::less ，它将委托给operator< ，

因此，为您的用户定义的数据类型创建一个新的std::less 。 现在这个新的std::less将由std::map默认选择。

namespace std
{
    template<> struct  less<MyClass>
    {
        bool operator() (const MyClass& lhs, const MyClass& rhs) const
        {
            return lhs.anyMemen < rhs.age;
        }
    };

}

注意：您需要为每个用户定义的数据类型创建专门的std::less （如果您想使用该数据类型作为 cpp 映射的键）。

错误的解决方案：为您的用户定义的数据类型重载operator< 。 这个解决方案也可以工作，但它非常糟糕，因为运算符<将普遍为您的数据类型/类重载。 这在客户端场景中是不可取的。

请检查答案Pavel Minaev 的答案

Answer 8

如果您只是添加，则您的示例在 C++20 中有效

auto operator<=>(Class1 const &) const = default;

到你的班级。