【C++中map和unordered_map存储自定义类型需要做什么】

目录

一、map存储自定义类型

 二、unordered_map存储自定义类型

---

一、map存储自定义类型

 需要传入的参数是key-value键值对，和仿函数类型

 对于内置类型，int、double、char重载了operator<所以传入less仿函数不会出错

但是对于自定义类型，如果不重载operator<就会出错

比如下面：传入自定义类型直接报错

#include <map>
#include <iostream>

class Person
{
public:
	int _age;

	Person(int age = -1) :_age(age)
	{}
};

int main()
{
	std::map<Person, int> um;
	um.insert(std::make_pair<Person, int>(Person(1), 1));
	um.insert(std::make_pair<Person, int>(Person(2), 1));

	for (auto& e : um)
	{
		std::cout << e.first._age << " " << e.second << std::endl;
	}
	return 0;
}

存储自定义类型进行传参的两种方法：

方法一：重载operator<

#include <map>
#include <iostream>

class Person
{
public:
	int _age;

	Person(int age = -1) :_age(age)
	{}

	// 重载operator<
	bool operator<(const Person& p) const
	{
		return _age < p._age;
	}
};

int main()
{
	std::map<Person, int> um;
	um.insert(std::make_pair<Person, int>(Person(1), 1));
	um.insert(std::make_pair<Person, int>(Person(2), 1));

	for (auto& e : um)
	{
		std::cout << e.first._age << ":" <<  e.second << std::endl;
	}

	return 0;
}

 方法二：自己定义比较规则：传入仿函数类型

#include <map>
#include <iostream>

class Person
{
public:
	int _age;

	Person(int age = -1):_age(age)
	{}
};

class PersonCmp
{
public:
	bool operator()(const Person& p1, const Person& p2) const
	{
		return p1._age < p2._age;
	}
};

int main()
{
	// 自定定义一个仿函数比较规则
	std::map<Person, int, PersonCmp> um;
	um.insert(std::make_pair<Person, int>(Person(1), 1));
	um.insert(std::make_pair<Person, int>(Person(2), 1));

	for (auto& e : um)
	{
		std::cout << e.first._age <<  " " << e.second << std::endl;
	}
	return 0;
}

 二、unordered_map存储自定义类型

 第一个参数：传入key值

第二个参数：传入T值

第三个参数哈希函数

对于内置类型支持可以支持哈希函数

 

第四个参数key的比较方式

对于内置类型是重载了比较方式的

 传入自定义类型什么也不做：
 

#include <iostream>
#include <unordered_map>

class Person
{
public:
	int _age;

	Person(int age = -1) :_age(age)
	{}
};

int main()
{
	std::unordered_map<Person, int> um;
	um.insert(std::make_pair<Person, int>(Person(1), 1));
	um.insert(std::make_pair<Person, int>(Person(2), 1));

	for (auto& e : um)
	{
		std::cout << e.first._age << " " << e.second << std::endl;
	}
	return 0;
}

 这个是会出问题的，重载operator ==，因为哈希表需要按照key进行查找，需要进行比较

以及定义哈希函数，因为没有系统的hash函数没有对自定义类型进行哈希

方法一：自定义类中重载operator == 和自定义hash函数，不传入第四个参数

#include <iostream>
#include <unordered_map>
#include <functional>

class Person
{
public:
	int _age;

	Person(int age = -1) :_age(age)
	{}

	bool operator == (const Person& p) const
	{
		return _age == p._age;
	}
};

struct PersonHash
{
public:
	size_t operator()(const Person& p) const
	{
		return std::hash<int>()(p._age);
	}
};

int main()
{
	std::unordered_map<Person, int, PersonHash> um;
	um.insert(std::make_pair<Person, int>(Person(1), 1));
	um.insert(std::make_pair<Person, int>(Person(2), 1));

	for (auto& e : um)
	{
		std::cout << e.first._age << " " << e.second << std::endl;
	}
	return 0;
}

 

 方法二：自定义hash函数和自定义key的比较规则

#include <iostream>
#include <unordered_map>
#include <functional>

class Person
{
public:
	int _age;

	Person(int age = -1) :_age(age)
	{}
};

struct PersonHash
{
public:
	size_t operator()(const Person& p) const
	{
		return std::hash<int>()(p._age);
	}
};

struct PersonEqual
{
public:
	bool operator()(const Person& p1, const Person& p2) const
	{
		return p1._age == p2._age;
	}
};

int main()
{
	std::unordered_map<Person, int, PersonHash, PersonEqual> um;
	um.insert(std::make_pair<Person, int>(Person(1), 1));
	um.insert(std::make_pair<Person, int>(Person(2), 1));

	for (auto& e : um)
	{
		std::cout << e.first._age << " " << e.second << std::endl;
	}
	return 0;
}

​​​​​​​