C++20下创建自定义结构体Point的std::unordered_set编译报错问题咨询

你遇到的这个编译错误，核心原因是std::unordered_set和你熟悉的std::set依赖的组件完全不同：

• std::set是有序容器，靠你实现的operator<来做排序和比较；
• 但std::unordered_set是哈希表容器，它需要两个关键东西才能正常工作：
  1. 一个能把Point转换成哈希值的哈希函数（标准库没有为自定义结构体提供默认的std::hash<Point>实现）
  2. 一个判断两个Point是否相等的比较逻辑（默认依赖operator==，但你的代码里只写了operator<）

编译器报错说默认构造函数被删除，本质是因为它找不到合法的哈希函数，导致unordered_set的默认构造逻辑无法生成。

下面给你两种常用的解决方式：

方式一：特化std::hash并补充operator== #

这种方式是让标准库能直接识别你的Point类型，不需要修改unordered_set的声明：

1. 先给Point结构体添加operator==，用于判断两个点是否相等：

bool operator==(const Point &p) const {
    return x == p.x && y == p.y;
}

2. 在全局命名空间下特化std::hash<Point>，提供哈希函数的实现：

namespace std {
    template<> struct hash<Point> {
        size_t operator()(const Point& p) const {
            // 把x和y的哈希值组合起来，避免碰撞
            size_t hash_x = hash<unsigned int>()(p.x);
            size_t hash_y = hash<unsigned int>()(p.y);
            // 这里用移位异或的方式组合，你也可以用其他更稳健的方式，比如 hash_x * 31 + hash_y
            return hash_x ^ (hash_y << 1);
        }
    };
}

完整的可编译代码如下：

#include <unordered_set>
using namespace std;

struct Point {
    unsigned int x;
    unsigned int y;
    // 用初始化列表简化构造函数，比你原来的写法更简洁
    Point(unsigned int x_value, unsigned int y_value) : x(x_value), y(y_value) {}
    Point(const Point &p) : x(p.x), y(p.y) {}
    
    // 必须的相等比较
    bool operator==(const Point &p) const {
        return x == p.x && y == p.y;
    }
    
    // 原来的operator<是给std::set用的，留着也不影响unordered_set
    bool operator<(const Point &p) const {
        return x < p.x || (x == p.x && y < p.y);
    }
};

// 特化std::hash，让标准库知道怎么哈希Point
namespace std {
    template<> struct hash<Point> {
        size_t operator()(const Point& p) const {
            size_t hash_x = hash<unsigned int>()(p.x);
            size_t hash_y = hash<unsigned int>()(p.y);
            return hash_x ^ (hash_y << 1);
        }
    };
}

int main() {
    unordered_set<Point> pset;
    pset.insert(Point(1, 2));
    return 0;
}

方式二：自定义哈希和比较器，作为unordered_set的模板参数 #

如果你不想修改std命名空间，可以自己写哈希类和比较类，在声明unordered_set的时候指定它们：

1. 定义自定义的哈希函数和相等比较器：

struct PointHash {
    size_t operator()(const Point& p) const {
        size_t hash_x = hash<unsigned int>()(p.x);
        size_t hash_y = hash<unsigned int>()(p.y);
        return hash_x ^ (hash_y << 1);
    }
};

struct PointEqual {
    bool operator()(const Point& a, const Point& b) const {
        return a.x == b.x && a.y == b.y;
    }
};

2. 声明unordered_set的时候，把这两个类作为模板参数传进去：

unordered_set<Point, PointHash, PointEqual> pset;

完整代码示例：

#include <unordered_set>
using namespace std;

struct Point {
    unsigned int x;
    unsigned int y;
    Point(unsigned int x_value, unsigned int y_value) : x(x_value), y(y_value) {}
    Point(const Point &p) : x(p.x), y(p.y) {}
    
    bool operator<(const Point &p) const {
        return x < p.x || (x == p.x && y < p.y);
    }
};

// 自定义哈希函数
struct PointHash {
    size_t operator()(const Point& p) const {
        size_t hash_x = hash<unsigned int>()(p.x);
        size_t hash_y = hash<unsigned int>()(p.y);
        return hash_x ^ (hash_y << 1);
    }
};

// 自定义相等比较器
struct PointEqual {
    bool operator()(const Point& a, const Point& b) const {
        return a.x == b.x && a.y == b.y;
    }
};

int main() {
    unordered_set<Point, PointHash, PointEqual> pset;
    pset.insert(Point(1, 2));
    return 0;
}

小提示 #

• 哈希函数的核心是尽量减少碰撞（不同的Point生成相同哈希值的情况），你可以根据需求调整组合方式，比如用hash_x * 31 + hash_y（31是一个常用的质数，能减少碰撞）。
• 如果你不需要用std::set，完全可以删掉operator<，因为unordered_set根本用不上它。

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