pair和make_pair
1、简介
class pair ，中文译为对组，可以个值视为将两一对于个单元。map和multimap，是就用pairs来管理value/key的成对元素。任何函数需要回传两个值，也需要pair。
该函数的相关内容如下所示：
|->Type----->struct
|->Include---> <utility>
|->Define----> pair<calss first,calss second>(first,second)
|
|->member
| |------>first
| |------>second
|
|->Sub
| |------>constructor（default,assignment,copy)
|
|->Fun
|------>operator(==,<,<=,>,>=,!=,=)
|------>make_pair(first,second) 返回一个新的pair
需求：
Header: <utility>
Namespace: std
2、stl源码
pair的源码
// TEMPLATE STRUCT pair
template<class _Ty1, class _Ty2>
struct pair {// store a pair of values
typedef pair<_Ty1, _Ty2> _Myt;
typedef _Ty1 first_type;
typedef _Ty2 second_type;
pair()
: first(_Ty1()), second(_Ty2())
{// construct from defaults
}
pair(const _Ty1& _Val1, const _Ty2& _Val2)
: first(_Val1), second(_Val2)
{// construct from specified values
}
template<class _Other1, class _Other2>
pair(const pair<_Other1, _Other2>& _Right)
: first(_Right.first), second(_Right.second)
{// construct from compatible pair
}
void swap(_Myt& _Right)
{// exchange contents with _Right
if (this != &_Right)
{// different, worth swapping
std::swap(first, _Right.first);
std::swap(second, _Right.second);
}
}
_Ty1 first;// the first stored value
_Ty2 second;// the second stored value
};
make_pair的源码
template<class _Ty1, class _Ty2>
inline pair<_Ty1, _Ty2> make_pair(_Ty1 _Val1, _Ty2 _Val2)
{
// return pair composed from arguments
return (pair<_Ty1, _Ty2>(_Val1, _Val2));
}
3、使用范例
#include <utility>
#include <stdio.h>
using namespace std;
int main()
{
pair<char, int> c1(L'x', 3);
printf("[%c, %d", c1.first, c1.second);
c1 = make_pair(L'y', 4);
printf("[{%c}, {%d}]", c1.first, c1.second);
return (0);
}
函数详解：
/** @file stl_pair.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#ifndef _PAIR_H
#define _PAIR_H 1
namespace std
{
/// pair holds two objects of arbitrary type.
template<class _T1, class _T2>
struct pair
{
typedef _T1 first_type; ///< @c first_type is the first bound type
typedef _T2 second_type; ///< @c second_type is the second bound type
_T1 first; ///< @c first is a copy of the first object
_T2 second; ///< @c second is a copy of the second object
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 265. std::pair::pair() effects overly restrictive
/** The default constructor creates @c first and @c second using their
* respective default constructors. */
pair()
: first(), second() { }
/** Two objects may be passed to a @c pair constructor to be copied. */
pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) { }
/** There is also a templated copy ctor for the @c pair class itself. */
template<class _U1, class _U2>
pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) { }
};
/// Two pairs of the same type are equal iff their members are equal.
template<class _T1, class _T2>
inline bool
operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first == __y.first && __x.second == __y.second; }
template<class _T1, class _T2>
inline bool
operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first < __y.first
|| (!(__y.first < __x.first) && __x.second < __y.second); }
/// Uses @c operator== to find the result.
template<class _T1, class _T2>
inline bool
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x == __y); }
/// Uses @c operator< to find the result.
template<class _T1, class _T2>
inline bool
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __y < __x; }
/// Uses @c operator< to find the result.
template<class _T1, class _T2>
inline bool
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__y < __x); }
/// Uses @c operator< to find the result.
template<class _T1, class _T2>
inline bool
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x < __y); }
/**
* @brief A convenience wrapper for creating a pair from two objects.
* @param x The first object.
* @param y The second object.
* @return A newly-constructed pair<> object of the appropriate type.
*
* The standard requires that the objects be passed by reference-to-const,
* but LWG issue #181 says they should be passed by const value. We follow
* the LWG by default.
*/
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 181. make_pair() unintended behavior
template<class _T1, class _T2>
inline pair<_T1, _T2>
make_pair(_T1 __x, _T2 __y) { return pair<_T1, _T2>(__x, __y); }
} // namespace std
#endif /* _PAIR_H */
有关的例子
#include <iostream>
#include <string>
#include <map>
#include <algorithm> //包含了很多头文件的头文件
typedef int KeyType; //换名称，易懂。
typedef std::pair<const KeyType,std::string> Pair;
//前一个为关键字，后一个为关键字的值
typedef std::multimap<KeyType,std::string> MapCode; //将复杂的名字换为简单的名字
int main(void)
{
using namespace std;
MapCode codes;
//类成员函数插入函数 insert
codes.insert(Pair(415,"San Francisco"));
codes.insert(Pair(510,"Oakland"));
codes.insert(Pair(718,"Brooklyn"));
codes.insert(Pair(718,"Staten Island"));
codes.insert(Pair(510,"San Rafael"));
codes.insert(Pair(415,"Berkeley"));
//用来给没个关键字的值计数
cout << "Number of cities with area code 415: "
<< codes.count(415) << endl;
cout << "Number of cities with area code 510: "
<< codes.count(510) << endl;
cout << "Number of cities with area code 718: "
<< codes.count(718) << endl;
cout << "Area Code City:/n";
MapCode::iterator it; //迭代器
for(it=codes.begin();it!=codes.end();it++)
cout << " " << (*it).first << " " << (*it).second << endl;
pair<MapCode::iterator,MapCode::iterator> range //此处记录迭代器
=codes.equal_range(718);
cout << "Cities with area code 718: " << endl;
//for(it=range.first;it!=range.second;++it)
it=range.first;
cout <<" " << (*it).first << " " << (*it).second << endl;
++it;
cout <<" " << (*it).first << " " << (*it).second << endl;
cin.get();
return 0;
}