C++

参考

<utility>

pair

function template
<utility>

std::relational operators (pair)

(1)
template <class T1, class T2>  bool operator== (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs);
(2)
template <class T1, class T2>  bool operator!= (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs);
(3)
template <class T1, class T2>  bool operator<  (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs);
(4)
template <class T1, class T2>  bool operator<= (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs);
(5)
template <class T1, class T2>  bool operator>  (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs);
(6)
template <class T1, class T2>  bool operator>= (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs);
pair 的关系运算符
在 lhs 和 rhs 这两个 pair 对象之间执行适当的比较操作。

如果两个 pair 对象的 first 成员彼此相等，并且 second 成员也彼此相等（在这两种情况下都使用 operator== 进行比较），则这两个对象相等。

类似地，运算符 <、>、<= 和 >= 在由成员 first 和 second 形成的序列上执行字典序比较（在所有情况下都使用 operator< 自反地进行比较）。

它们的行为就好像定义为
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
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); }

这些运算符在头文件 <utility> 中被重载。

参数

lhs, rhs
pair 对象（分别位于运算符的左侧和右侧），具有相同的模板参数（T1 和 T2）。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
// pair relational operators
#include <utility>      // std::pair
#include <iostream>     // std::cout

int main ()
{
  std::pair<int,char> foo (10,'z');
  std::pair<int,char> bar (90,'a');

  if (foo==bar) std::cout << "foo and bar are equal\n";
  if (foo!=bar) std::cout << "foo and bar are not equal\n";
  if (foo< bar) std::cout << "foo is less than bar\n";
  if (foo> bar) std::cout << "foo is greater than bar\n";
  if (foo<=bar) std::cout << "foo is less than or equal to bar\n";
  if (foo>=bar) std::cout << "foo is greater than or equal to bar\n";

  return 0;
}

输出
foo and bar are not equal
foo is less than bar
foo is less than or equal to bar


返回值

如果条件成立，则为 true；否则为 false。

数据竞争

访问两个对象 lhs 和 rhs，并访问最多其所有成员。
在任何情况下，该函数都无法修改其参数（const 限定）。

异常安全

如果成员的类型支持具有无异常保证的适当操作，则该函数永远不会引发异常（无异常保证）。
如果成员的类型不支持使用适当的运算符进行比较，则会导致未定义的行为。

另见

pair::operator=
赋值内容 (公开成员函数)
pair::swap
交换内容 (公开成员函数)