如何将自定义对象用作std::map的键？无大小比较场景处理方法

你遇到的问题很典型——std::map底层依赖红黑树实现，要求键类型必须支持严格弱序的比较逻辑，你的示例代码里写的operator<只是为了编译通过，完全不符合这个要求，所以运行起来会出问题（比如第二个元素可能无法正确插入，或者map的结构完全混乱）。下面我分两种场景给你讲解决方案：

场景1：可以给对象定义合理的“小于”逻辑（严格弱序） #

std::map要求比较操作满足严格弱序，简单说就是：

• 如果a < b为真，那么b < a必须为假
• 如果a < b且b < c，那么a < c必须为真
• 如果a不小于b，且b不小于a，则认为a和b是等价的（map会把它们当成同一个键）

给你的Object类写一个正确的operator<重载就可以解决问题，比如按成员变量的优先级比较：

#include <map>
class Object {
public:
    int x, y;
    Object(int x, int y) : x(x), y(y) {};
    // 正确的严格弱序实现：先比x，x相等再比y
    bool operator<(const Object& o) const {
        if (x != o.x) {
            return x < o.x;
        }
        return y < o.y;
    };
};
int main() {
    Object o1(1, 2), o2(3, 4);
    std::map<Object, int> objmap;
    objmap.insert(std::make_pair(o1, 11));
    objmap.insert(std::make_pair(o2, 22));
    // 现在可以正常使用了
}

场景2：对象无法定义“小于”关系，仅能判断是否相等 #

如果你的对象逻辑上没有“大小”的概念，只有“相等/不等”的判断，那有两个可行方案：

方案1：给std::map传入自定义比较器 #

你不需要重载operator<，而是写一个独立的比较器结构体，实现严格弱序的比较逻辑（哪怕是人为构造的顺序），然后把它作为std::map的第三个模板参数：

#include <map>
class Object {
public:
    int x, y;
    Object(int x, int y) : x(x), y(y) {};
    // 先实现相等判断（可选，但逻辑上更清晰）
    bool operator==(const Object& o) const {
        return x == o.x && y == o.y;
    }
};

// 自定义比较器：构造严格弱序的规则
struct ObjectComparator {
    bool operator()(const Object& a, const Object& b) const {
        // 这里的顺序是人为定义的，只要满足严格弱序即可
        if (a.x != b.x) {
            return a.x < b.x;
        }
        return a.y < b.y;
    }
};

int main() {
    Object o1(1, 2), o2(3, 4);
    // 使用自定义比较器的map
    std::map<Object, int, ObjectComparator> objmap;
    objmap.insert(std::make_pair(o1, 11));
    objmap.insert(std::make_pair(o2, 22));
}

这里的关键是：比较器只需要满足严格弱序，不一定是业务逻辑上的“小于”，只要能稳定地区分出等价元素，给其他元素一个一致的排序规则就行。

方案2：改用std::unordered_map（哈希表） #

如果你的场景不需要有序的键，那么改用std::unordered_map会更合适——它底层是哈希表，不需要比较大小，只需要两个东西：

1. 键类型的相等判断（重载operator==）
2. 键类型的哈希函数

示例代码如下：

#include <unordered_map>
class Object {
public:
    int x, y;
    Object(int x, int y) : x(x), y(y) {};
    // 必须的相等判断
    bool operator==(const Object& o) const {
        return x == o.x && y == o.y;
    }
};

// 自定义哈希函数
struct ObjectHasher {
    size_t operator()(const Object& obj) const {
        // 组合x和y的哈希值，避免哈希碰撞
        size_t hash = std::hash<int>()(obj.x);
        // 常用的哈希组合方式
        hash ^= std::hash<int>()(obj.y) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
        return hash;
    }
};

int main() {
    Object o1(1, 2), o2(3, 4);
    std::unordered_map<Object, int, ObjectHasher> objmap;
    objmap.insert(std::make_pair(o1, 11));
    objmap.insert(std::make_pair(o2, 22));
}

如果你不想每次都传哈希器，也可以特化std::hash模板：

namespace std {
    template<> struct hash<Object> {
        size_t operator()(const Object& obj) const {
            size_t hash = hash<int>()(obj.x);
            hash ^= hash<int>()(obj.y) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
            return hash;
        }
    };
}
// 这样就可以直接用：std::unordered_map<Object, int> objmap;

内容的提问来源于stack exchange，提问作者Jabberwocky