【C++】键值对pair的使用和模拟实现

---

 
 
 

1. piar的介绍

---

在 C++ 中， pair 是一个标准库模板，它将两个不同类型的值组合成一个对。 pair 通常用于将相关的两个值（例如键值对、坐标、元素和重量等）封装在一起，以便于处理和传递。

相关文档：pair
该类将一对不同类型的值(T1和T2)耦合在一起。单个值可以通过它的公共成员第一个和第二个来访问。

 
 

2. pair的使用

---

1. 键值对： pair 常用于表示键值对，其中第一个元素表示键，第二个元素表示值。例如，在映射（ map ）或无序映射（ unordered_map ）中，可以使用 pair 来存储键和对应的值。
2. 返回多个值：当一个函数需要返回两个或更多相关的值时，可以使用 pair 。这样可以将多个值作为一个整体返回，而不是使用多个单独的返回值。
3. 存储相关数据：如果有两个数据项总是一起出现并且具有相关的意义，例如坐标（x 和 y）、元素和重量、学生和成绩等，可以使用 pair 来方便地存储和操作这些相关的数据。
4. 参数传递：在函数参数中，可以使用 pair 来传递两个相关的值，使得函数可以接收和处理这两个值。

以下是一个简单的示例，展示了如何使用 pair ：

#include <iostream>
#include <utility>

void processPair(const std::pair<int, std::string>& pairData) {
	int key = pairData.first;
	std::string value = pairData.second;
	// 处理键和值
	std::cout << "Key: " << key << ", Value: " << value << std::endl;
}

int main() {
	std::pair<int, std::string> pair(123, "Hello, World!");

	processPair(pair);

	return 0;
}

在上述示例中，定义了一个 pair 对象 pair(123, "Hello, World!") ，其中 123 是键， "Hello, World!" 是值。然后，将 pair 对象作为参数传递给 processPair 函数，在函数内部通过 .first 和 .second 成员访问键和值。

 
 

3. pair的模拟实现

---

想要模拟实现pair，就要先去多看看它的一些接口说明，我这里只是以模板的方式简单的模拟实现一些常用的接口。

以下是我模拟实现的一个pair结构体，其中比较大小的操作符我是按照库里面的方式进行实现的（实际中我们很少会用到库里面的实现方式，都是用自己写的仿函数）。经过测试，构造，拷贝构造都没有什么问题

namespace hyt
{
	template<class T1, class T2>
	struct pair
	{
		template<class T>
		void swap(T& x, T& y)
		{
			T tmp = x;
			x = y;
			y = x;
		}
		// 声明清楚T1是第一个类型,T2是第二个类型
		typedef T1 first_type;
		typedef T2 second_type;
		// 成员变量
		T1 first;
		T2 second;
		pair() // 构造函数
			:first(T1())
			,second(T2())
		{}
		pair(const T1& _first, const T2& _second) // 构造函数
			:first(_first)
			, second(_second)
		{}
		template<class U1, class U2>
		pair(const pair<U1, U2>& p) // 拷贝构造
			:first(p.first)
			,second(p.second)
		{}

		pair<T1, T2>& operator=(pair<T1, T2> p) // 赋值重载
		{
			// 如果T1或T2为一个需要开辟空间的类型,
			// 直接赋值的话可能会造成this指针原本指向的空间丢失,
			// 这里写成这样的目的是为了防止内存泄漏,
			swap<T1>(first, p.first);
			swap<T2>(second, p.second);
			return *this;
		}
	};
	// Non-member function overloads
	template <class T1, class T2>
	bool operator== (const pair<T1, T2>& lhs, const pair<T1, T2>& rhs)
	{
		return lhs.first == rhs.first && lhs.second == rhs.second;
	}

	template <class T1, class T2>
	bool operator!= (const pair<T1, T2>& lhs, const pair<T1, T2>& rhs)
	{
		return !(lhs == rhs);
	}

	template <class T1, class T2>
	bool operator<  (const pair<T1, T2>& lhs, const pair<T1, T2>& rhs)
	{
		return lhs.first < rhs.first || (!(rhs.first < lhs.first) && lhs.second < rhs.second);
	}

	template <class T1, class T2>
	bool operator<= (const pair<T1, T2>& lhs, const pair<T1, T2>& rhs)
	{
		return !(rhs < lhs);
	}

	template <class T1, class T2>
	bool operator>  (const pair<T1, T2>& lhs, const pair<T1, T2>& rhs)
	{
		return rhs < lhs;
	}

	template <class T1, class T2>
	bool operator>= (const pair<T1, T2>& lhs, const pair<T1, T2>& rhs)
	{
		return !(lhs < rhs);
	}
	
	template <class T1, class T2>
	pair<T1, T2> make_pair(T1 x, T2 y)
	{
		return (pair<T1, T2>(x, y));
	}
}