STL pair make_pair简单使用

最新推荐文章于 2022-10-04 01:28:00 发布
最新推荐文章于 2022-10-04 01:28:00 发布
阅读量1.2k 收藏
点赞数
分类专栏： stl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011922261/article/details/21203633
版权

今天再看《c++标准库》，遇到了以前貌似有点印象的pair,特意记录下来，免得以后忘记了。下面是在vs查看pair定义的一部分代码（貌似很多，只贴一部分）

template<class _Ty1,
	class _Ty2>
	struct pair
		: public _Pair_base<_Ty1, _Ty2>
	{	// store a pair of values
	typedef _Pair_base<_Ty1, _Ty2> _Mybase;

	typedef pair<_Ty1, _Ty2> _Myt;
	typedef _Ty1 first_type;
	typedef _Ty2 second_type;

	pair()
		: _Mybase()
		{	// construct from defaults
		}

	pair(const _Ty1& _Val1, const _Ty2& _Val2)
		: _Mybase(_Val1, _Val2)
		{	// construct from specified values
		}

	template<class _Other1,
		class _Other2>
		pair(pair<_Other1, _Other2>& _Right)
		: _Mybase(_Right.first, _Right.second)
		{	// construct from compatible pair
		}

	template<class _Other1,
		class _Other2>
		pair(const pair<_Other1, _Other2>& _Right)
		: _Mybase(_Right.first, _Right.second)
		{	// construct from compatible pair
		}

	void swap(_Myt& _Right)
		{	// exchange contents with _Right
		if (this != &_Right)
			{	// different, worth swapping
			_Swap_adl(this->first, _Right.first);
			_Swap_adl(this->second, _Right.second);
			}
		}

	_Myt& operator=(const _Myt& _Right)
		{	// assign from copied pair
		this->first = _Right.first;
		this->second = _Right.second;
		return (*this);
		}

	typedef typename tr1::remove_reference<_Ty1>::type _Ty1x;
	typedef typename tr1::remove_reference<_Ty2>::type _Ty2x;

	pair(_Ty1x&& _Val1, _Ty2x&& _Val2)
		: _Mybase(_STD move(_Val1),
			_STD move(_Val2))
		{	// construct from specified values
		}

	pair(const _Ty1x& _Val1, _Ty2x&& _Val2)
		: _Mybase(_Val1,
			_STD move(_Val2))
		{	// construct from specified values
		}

	pair(_Ty1x&& _Val1, const _Ty2x& _Val2)
		: _Mybase(_STD move(_Val1),
			_Val2)
		{	// construct from specified values
		}

	template<class _Other1,
		class _Other2>
		pair(_Other1&& _Val1, _Other2&& _Val2)
		: _Mybase(_STD forward<_Other1>(_Val1),
			_STD forward<_Other2>(_Val2))
		{	// construct from moved values
		}

	template<class _Other1,
		class _Other2>
		pair(pair<_Other1, _Other2>&& _Right)
		: _Mybase(_STD forward<_Other1>(_Right.first),
			_STD forward<_Other2>(_Right.second))
		{	// construct from moved compatible pair
		}

	pair& operator=(pair<_Ty1, _Ty2>&& _Right)
		{	// assign from moved pair
		this->first = _STD move(_Right.first);
		this->second = _STD move(_Right.second);
		return (*this);
		}

	void swap(_Myt&& _Right)
		{	// exchange contents with _Right
		if (this != &_Right)
			{	// different, worth swapping
			this->first = _STD move(_Right.first);
			this->second = _STD move(_Right.second);
			}
		}
	};

		// pair TEMPLATE FUNCTIONS

template<class _Ty1,
	class _Ty2> inline
	void swap(pair<_Ty1, _Ty2>& _Left, pair<_Ty1, _Ty2>& _Right)
	{	// swap _Left and _Right pairs
	_Left.swap(_Right);
	}

template<class _Ty1,
	class _Ty2> inline
	void swap(pair<_Ty1, _Ty2>& _Left, pair<_Ty1, _Ty2>&& _Right)
	{	// swap _Left and _Right pairs
	typedef pair<_Ty1, _Ty2> _Myt;
	_Left.swap(_STD forward<_Myt>(_Right));
	}

template<class _Ty1,
	class _Ty2> inline
	void swap(pair<_Ty1, _Ty2>&& _Left, pair<_Ty1, _Ty2>& _Right)
	{	// swap _Left and _Right pairs
	typedef pair<_Ty1, _Ty2> _Myt;
	_Right.swap(_STD forward<_Myt>(_Left));
	}

template<class _Ty1,
	class _Ty2> inline
	bool operator==(const pair<_Ty1, _Ty2>& _Left,
		const pair<_Ty1, _Ty2>& _Right)
	{	// test for pair equality
	return (_Left.first == _Right.first && _Left.second == _Right.second);
	}

template<class _Ty1,
	class _Ty2> inline
	bool operator!=(const pair<_Ty1, _Ty2>& _Left,
		const pair<_Ty1, _Ty2>& _Right)
	{	// test for pair inequality
	return (!(_Left == _Right));
	}

template<class _Ty1,
	class _Ty2> inline
	bool operator<(const pair<_Ty1, _Ty2>& _Left,
		const pair<_Ty1, _Ty2>& _Right)
	{	// test if _Left < _Right for pairs
	return (_Left.first < _Right.first ||
		!(_Right.first < _Left.first) && _Left.second < _Right.second);
	}

template<class _Ty1,
	class _Ty2> inline
	bool operator>(const pair<_Ty1, _Ty2>& _Left,
		const pair<_Ty1, _Ty2>& _Right)
	{	// test if _Left > _Right for pairs
	return (_Right < _Left);
	}

template<class _Ty1,
	class _Ty2> inline
	bool operator<=(const pair<_Ty1, _Ty2>& _Left,
		const pair<_Ty1, _Ty2>& _Right)
	{	// test if _Left <= _Right for pairs
	return (!(_Right < _Left));
	}

template<class _Ty1,
	class _Ty2> inline
	bool operator>=(const pair<_Ty1, _Ty2>& _Left,
		const pair<_Ty1, _Ty2>& _Right)
	{	// test if _Left >= _Right for pairs
	return (!(_Left < _Right));
	}

	// TEMPLATE FUNCTION make_pair

template<class _Ty1,
	class _Ty2> inline
	pair<typename _Unrefwrap<_Ty1>::type,
		typename _Unrefwrap<_Ty2>::type>
		make_pair(_Ty1&& _Val1, _Ty2&& _Val2)
	{	// return pair composed from arguments
	typedef pair<typename _Unrefwrap<_Ty1>::type,
		typename _Unrefwrap<_Ty2>::type> _Mypair;
	return (_Mypair(_STD forward<_Ty1>(_Val1),
		_STD forward<_Ty2>(_Val2)));
	}

template<class _Ty1,
	class _Ty2> inline
	pair<typename _Unrefwrap<_Ty1>::type,
		typename _Unrefwrap<_Ty2>::type>
		make_pair(const _Ty1& _Val1, _Ty2&& _Val2)
	{	// return pair composed from arguments
	typedef pair<typename _Unrefwrap<_Ty1>::type,
		typename _Unrefwrap<_Ty2>::type> _Mypair;
	return (_Mypair((typename _Unrefwrap<_Ty1>::type)_Val1,
		_STD forward<_Ty2>(_Val2)));
	}

template<class _Ty1,
	class _Ty2> inline
	pair<typename _Unrefwrap<_Ty1>::type,
		typename _Unrefwrap<_Ty2>::type>
		make_pair(_Ty1&& _Val1, const _Ty2& _Val2)
	{	// return pair composed from arguments
	typedef pair<typename _Unrefwrap<_Ty1>::type,
		typename _Unrefwrap<_Ty2>::type> _Mypair;
	return (_Mypair(_STD forward<_Ty1>(_Val1),
		(typename _Unrefwrap<_Ty2>::type)_Val2));
	}

template<class _Ty1,
	class _Ty2> inline
	pair<typename _Unrefwrap<_Ty1>::type,
		typename _Unrefwrap<_Ty2>::type>
		make_pair(const _Ty1& _Val1, const _Ty2& _Val2)
	{	// return pair composed from arguments
	typedef pair<typename _Unrefwrap<_Ty1>::type,
		typename _Unrefwrap<_Ty2>::type> _Mypair;
	return (_Mypair((typename _Unrefwrap<_Ty1>::type)_Val1,
		(typename _Unrefwrap<_Ty2>::type)_Val2));
	}

 #if _HAS_CPP0X
template<class _InIt> inline
	_InIt begin(const pair<_InIt, _InIt>& _Pair)
	{	// return first element of pair
	return (_Pair.first);
	}

template<class _InIt> inline
	_InIt end(const pair<_InIt, _InIt>& _Pair)
	{	// return second element of pair
	return (_Pair.second);
	}
 #endif /* _HAS_CPP0X */

		// TEMPLATE OPERATORS
	namespace rel_ops
		{	// nested namespace to hide relational operators from std
template<class _Ty> inline
	bool operator!=(const _Ty& _Left, const _Ty& _Right)
	{	// test for inequality, in terms of equality
	return (!(_Left == _Right));
	}


很乱是吧(ps：我也不知道贴的对不对，哈哈...)不过从上面的代码中大概可以看出，它已经帮我们实现了一些基本的运行,例如swap（两个pair数据的交换），还有paire的比较等。下面是测试代码（环境vs2010）:

#include <iostream>
#include <utility>//使用pair需要添加此文件才能识别
#include <string>
using namespace std;
int  main()
{
	cout<<"Hello ,STL Paire"<<endl;

	pair<string,int>p1 ("vegetables",4);
	pair<string,int>p2;

	p2.first = "people";
	p2.second = 5.99;

	pair<string,double>p3 = make_pair("lining",361.0);
	pair<string,int>p4 = make_pair("anta",400);

	cout<<"p1.first:"<<p1.first<<"  ,p1.second:"<<p1.second<<endl;
	cout<<"p2.first:"<<p2.first<<"  ,p2.second:"<<p2.second<<endl;
	cout<<"p3.first:"<<p3.first<<"  ,p3.second:"<<p2.second<<endl;

	p2.swap(p1);//交换两个paire值
	cout<<"p1.first:"<<p1.first<<"  ,p1.second:"<<p1.second<<endl;
	cout<<"p2.first:"<<p2.first<<"  ,p2.second:"<<p2.second<<endl;

	cout<<"p2<p1 is  "<<(p2<p1)<<endl;//源码已经重载了<,>,==等一些运算。
	//cout<<"p3<p4 is  "<<(p3<p4)<<endl//这里如果这样，编译不过去，貌似比较的两个pair值得键和值的类型都一样，如果改成一样就可以编译过去了
	system("pause");
	return 0;
}

输出结果：

注:STL容器中的map和mutimap就是使用pairs来管理键值对。任何函数需要返回两个值，也需要pair.还有就是两个pair互相比较时，第一元素具有较高的优先级。所以两个pairs的的第一元素不相等，其比较结果就成为整个比较行为的结果。如果第一元素相等，才继续比较第二元素，并把比较结果当做整体比较结果。

好了，睡觉，明天继续加油啃《c++标准库》奋斗。



不游泳的鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
stl文件读取_matlab读取stl文件形成点云_读取stl文件_读取stl_形貌_形貌扫描云图_
10-03
用于三维光学形貌扫描完成后，生成的stl文件的读取，并形成俯视投影云图
STL map详细用法和make_pair函数
sinb妃的博客
07-17 3294
首先make_pair Pairs C++标准程序库中凡是“必须返回两个值”的函数， 也都会利用pair对象 class pair可以将两个值视为一个单元。容器类别map和multimap就是使用pairs来管理其健值/实值(key/va lue)的成对元素。 pair被定义为struct,因此可直接存取pair中的个别值. 两个pairs互相比较时， 第一个元素正具有较高的优先级. 例： nam...
【C++】STL中 pair 和 make_pair 的关系
大熊的笔记
06-21 691
文章目录概述参考链接 概述 pair 对组将2个数据组合，如 stl 中的 map 就是将 key 和 value 放在一起来保存。当一个函数需要返回2个数据的时候，可以选择 pair。 pair 的实现是一个结构体，主要的两个成员变量是 first 和 second，因为是使用 struct 不是 class，所以可以直接使用 pair 的成员变量。具体参见：C++ class和struct的区别 pair是二元组类模版，make_pair实际上是创建二元组的函数模版，在C++中，函数模版可省略参数，ma
C++ make_pair和map用法
qq_24447809的博客
10-11 2097
make_pair不需要指定参数类型，如pair<int,int>； 见代码： #include<iostream> #include<map> #include<vector> #include<ctime> #include<string> #include<sstream> using namespace std; int main() { map<pair<int, int>, int&g
STL中的模板类pair ,make_pair和map
zz460833359的博客
09-05 3310
1 pair的应用 pair是将2个数据组合成一个数据，当需要这样的需求时就可以使用pair，如stl中的map就是将key和value放在一起来保存。另一个应用是，当一个函数需要返回2个数据的时候，可以选择pair。 pair的实现是一个结构体，主要的两个成员变量是first second 因为是使用struct不是class，所以可以直接使用pair的成员变量。 2 mak
stl map用法和make_pair函数
热门推荐
SprintfWater的专栏
04-06 3万+
首先make_pair Pairs  C++标准程序库中凡是“必须返回两个值”的函数， 也都会利用pair对象  class pair可以将两个值视为一个单元。容器类别map和multimap就是使用pairs来管理其健值/实值(key/va lue)的成对元素。  pair被定义为struct,因此可直接存取pair中的个别值.
STL.rar_学习使用STL
09-19
详尽讲解STL的方法以及运用，是C学习阶段加强STL使用的很好资料
STL.rar_c++ 容器使用
09-24
STL方面内容,介绍C++ STL容器的使用；
sgi-STL.rar_STL_sgi_sgi stl
09-23
介绍标准模板库（STL）的重要参考资料。
STL.rar_STL_STL PPT_iterator_stl p
09-21
stl的入门ppt 很好用哦，分为导入 STL的概念与组成 Iterator（迭代器） Container（容器） Algorithm（算法） Adaptors（配接器）
c++ 中 pair 的 使用方法
Fate_Dream的博客
12-17 4000
std::pair主要的作用是将两个数据组合成一个数据，两个数据可以是同一类型或者不同类型。例如std::pair 或者 std：：pair等。pair实质上是一个结构体，其主要的两个成员变量是first和second，这两个变量可以直接使用。初始化一个pair可以使用构造函数，也可以使用std::make_pair函数，make_pair函数的定义如下： template pair make_
【C/C++】STL map用法、插入方法、pair和make_pair的区别
小鱼菜鸟的博客
10-04 987
目录 使用和方法 map的基本操作函数 map插入数据的4种方法 4种插入数据的方法 4种方法的区别 map其他用法 make_pair map的大小.size() 数据的遍历-迭代器/数组 数据的查找-count/find/ 数据的清空与判空 数据的删除 排序 其他一些函数用法 结束语 map的原理和特点 ma...
STL之makepair
心之所向
08-08 469
一、引用#include <utility> //注意不是pair二、使用// 初始化 pair<int, double> p(1, 2.1); //用给定值初始化 pair<int, double> p(p1); pair<int, double> p = p1;// 访问值或赋值 p.first = 4; p.second = 7; // 或者赋值 p = make_pair(1, 1.2)
智能指针
qq_41078889的博客
07-09 759
智能指针是为了方便管理动态内存，防止产生内存泄漏，而对指针进行的一层封装，可以通过析构函数，构造函数，赋值运算符重载的处理，而实现的可以自动管理指针所指向的动态内存，防止产生内存泄漏。定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释放。智能指针：主要有Boost库中的智能指针和STL标准库中的智能指针构成。 所有智能指针编写代码时都需要注意的事： 智能指针编写的时候，因为不知道指向的是何种类型的堆内存，所以都写成模板形式 注
日常学习之 std::pair
yt.yuuuu.被坑的那些事
08-10 411
日常学习之 std::pair 首先，看下定义template这里写代码片
pair 和make_pair比较，以及在map中的用法
u010274106的专栏
05-04 3249
Pair和make_pair类型概述 1.pair是一种模板类型，其中包含两个数据值，两个数据的类型可以不同. eg:pair a; 表示a中有两个类型，比如第一个元素可以是int型的，第二个元素是string类型的，如果创建pair的时候没有对其进行初始化，则调用默认构造函数对其初始化。 pair a("James", "Joy"); 由于pair类型的使用
make_pair函数
最新发布
05-24
make_pair是一个 STL 中的函数模板，用于构造一个标准库中的pair对象，pair对象由两个值组成，通常是两个不同类型的值。 make_pair函数的语法如下： ```c++ template <class T1, class T2> pair<T1, T2> make_pair (T1 x, T2 y); ``` 其中，T1 和 T2 分别表示pair对象的两个元素的类型，x和y分别为这两个元素的值。 例如，我们可以这样使用make_pair函数创建一个int和一个string组成的pair对象： ```c++ pair<int, string> myPair = make_pair(10, "hello"); ``` 这将创建一个myPair对象，其第一个元素是整数10，第二个元素是字符串"hello"。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值