unordered_map和map中结构体为key值的处理

一、unordered_map中结构体为key时

这里有两种方式处理，方式1在结构体内部重载operator"()"和"operator=="运算符；方式2在结构体外部对"operator=="重载，同时利用hash的模板对Student(本例中定义的结构体)类型进行特化；具体的两种方式如下：

方式1

#include<iostream>
#include<unordered_map>
#include<string>

struct Student {
	Student() {};
	Student(std::string name_, int age_) : name(name_), age(age_) {};
	std::string name;
	int age;
	size_t operator()(const Student& stu1) const { //这里的const不要忘记
		return std::hash<std::string>{}(stu1.name) ^ std::hash<int>{}(stu1.age);
	}
	bool operator==(const Student& stu1) const {
		return (age == stu1.age) && (name == stu1.name);
	}
};
int main() {
	std::unordered_map<Student, int, student> stuMap;
	Student zhangsan("zhangsan", 21);
	Student lisi("lisi", 26);
	Student wangwu("wangwu", 23);

	stuMap[zhangsan] = 96;
	stuMap[lisi] = 93;
	stuMap[wangwu] = 89;
	for (auto& stu : stuMap) {
		std::cout << stu.first.name << ":" << stu.second << std::endl;
	}
	return 0;
}

方式2

#include<iostream>
#include<unordered_map>
#include<string>

struct Student {
	Student() {};
	Student(std::string name_, int age_) : name(name_), age(age_) {};
	std::string name;
	int age;
};

bool operator==(const Student& stu1, const Student& stu2) {
	return (stu1.age == stu2.age) && (stu1.name == stu2.name);
}

// 方式2 定义全局的哈希函数
namespace std {
	template<> struct hash<Student> {
		size_t operator()(const Student& stu) const {
			return std::hash<std::string>{}(stu.name) ^ std::hash<int>{}(stu.age);
		}
	};
}

int main() {
	std::unordered_map<Student, int> stuMap;
	Student zhangsan("zhangsan", 21);
	Student lisi("lisi", 26);
	Student wangwu("wangwu", 23);

	stuMap[zhangsan] = 96;
	stuMap[lisi] = 93;
	stuMap[wangwu] = 89;
	for (auto& stu : stuMap) {
		std::cout << stu.first.name << ":" << stu.second << std::endl;
	}
	return 0;
}

当然也可以根据unordered_map的定义对其进行传参初始化定义,这种方式和上述两种方式大同小异。如定义一个比较返回hash值的仿函数如下:

Struct MyCompare{
	size_t operator()(const Student& stu){
		return std::hash<int>{}(stu.age) ^ std::hash<std::string>{}(stu.name);
	}
}

再定义一个键值相等判断函数：

Struct IsEqual{
	bool operator==(const Student& stu1, const Student& stu2){
		return (stu1.age == stu2.age) && (stu1.name == stu2.name);
	}
}

全部代码如下：

#include<iostream>
#include<unordered_map>
#include<string>

struct Student {
	Student() {};
	Student(std::string name_, int age_) : name(name_), age(age_) {};
	std::string name;
	int age;
};

Struct MyCompare{
	size_t operator()(const Student& stu){
		return std::hash<int>{}(stu.age) ^ std::hash<std::string>{}(stu.name);
	}
}

Struct IsEqual{
	bool operator==(const Student& stu1, const Student& stu2){
		return (stu1.age == stu2.age) && (stu1.name == stu2.name);
	}
}

int main() {
	std::unordered_map<Student, int, MyCompare, IsEqual> stuMap;
	Student zhangsan("zhangsan", 21);
	Student lisi("lisi", 26);
	Student wangwu("wangwu", 23);

	stuMap[zhangsan] = 96;
	stuMap[lisi] = 93;
	stuMap[wangwu] = 89;
	for (auto& stu : stuMap) {
		std::cout << stu.first.name << ":" << stu.second << std::endl;
	}
	return 0;
}

二、map中结构体为key时

在C++中，map是一个关联容器，它存储的元素是键值对，其中键和值可以是任何类型。map内部使用一种名为红黑树的数据结构来存储元素。红黑树是一种自平衡二叉查找树，它需要比较元素来维持树的平衡。

当我们使用自定义类型（如结构体）作为map的键时，我们需要提供一种方法来比较这些键。这就是为什么我们需要在结构体中重载<运算符。重载后的<运算符定义了如何比较两个结构体对象。

例如，如果我们有一个名为MyStruct的结构体，并且我们想要使用它作为map的键，那么我们可以这样重载<运算符：

struct MyStruct {
    int a;
    int b;
    bool operator < (const MyStruct& other) const {
        // 这里定义了如何比较两个MyStruct对象
        if (a != other.a) return a < other.a;
        else return b < other.b;
    }
};

这样，我们就可以创建一个以MyStruct为键的map了：

std::map<MyStruct, int> myMap;

请注意，重载的<运算符必须能够对所有可能的键值对进行唯一且一致的比较。也就是说，对于任意两个不同的键，重载的<运算符必须总是返回相同的结果。否则，map可能无法正确地存储和检索元素。
举例如下：

#include <iostream>
#include <map>

struct MyStruct {
    int key;
    // Other members of MyStruct
    /**	方式2
    *	bool operator()(const MyStruct& mine)const {
    *   	return key < mine.key;
    *	}
    */
};


// 这里的operator==等号运算符也可以在结构体内部重载，如果是在内部重载的话，定义map的时候只需要传入两个参数
struct CompareMyStruct {
    bool operator()(const MyStruct& left, const MyStruct& right) const {
        return left.key < right.key;
    }
};

int main() {
    std::map<MyStruct, int, CompareMyStruct> myMap;
    // std::map<MyStruct, int> myMap; // 方式2
    MyStruct key1 = {2};
    MyStruct key2 = {1};
    MyStruct key3 = {3};

    myMap[key1] = 20;
    myMap[key2] = 10;
    myMap[key3] = 30;

    for (const auto& pair : myMap) {
        std::cout << pair.first.key << ": " << pair.second << std::endl;
    }
    return 0;
}