在本文中，我们将研究在C++标准模板库(STL)中使用对。

这是一个非常有用的容器，可减轻使用单个返回类型的麻烦。

与Python中的元组类似，std :: pair模板类是在一个变量中具有多个对象的C++方法。

让我们看看如何使用它，使用一些说明性示例！

std :: pair的基本语法

这是在" std"名称空间中，因此我们需要在使用名称空间名称之前添加前缀。

这是一个模板类，并且可以根据类型采用模板化参数。

template <class T1, class T2> struct pair;

要声明一个名为" my_pair"的对变量，语法如下：

std::pair<typename T1, typename T2> my_pair;

其中" T1"和" T2"可以是任何类型，例如" int"，" char"，" string"等。

现在我们声明了pair变量，现在让我们对其进行定义。

一对具有两个元素，分别称为第一个和第二个。

• 要获取/设置第一个元素，请使用" my_pair.first"。

• 要获取/设置第二个元素，请使用" my_pair.second"。

元素必须是声明中符合" T1"和" T2"的适当类型。

现在，将对元素分配给特定值。

我们将构建一对std :: pair <int，char>，并将其相应地分配给2个值。

#include <iostream>

int main() {

  //Define my_pair
  std::pair<int, char> my_pair;

  //Now assign the first element to an integer
  my_pair.first = 10;

  //And the second element to a character
  my_pair.second = 'H';

  std::cout << "First element : " << my_pair.first << std::endl;
  std::cout << "Second element : " << my_pair.second << std::endl;
  return 0;
}

输出

First element : 10
Second element : H

如您所见，我们可以轻松地操作对元素！

在C++ STL中初始化配对

我们还可以使用其构造函数直接初始化对变量！

看下面的例子，它直接构造了一对。

其中我使用了auto关键字，这对于自动类型推断非常有用！

我们不需要一次又一次地写出巨大的std :: pair <>！

#include <iostream>
#include <string>

int main() {
  //Initialize a pair directly!
  auto my_pair = std::pair<int, std::string>(1, "Hello");

  std::cout << "First element : " << my_pair.first << std::endl;
  std::cout << "Second element : " << my_pair.second << std::endl;
  return 0;
}

输出

First element : 1
Second element : Hello

确实，我们能够直接初始化对变量。

使用std :: make_pair()进行简洁的初始化

初始化对的另一种方法是使用std :: make_pair(T1 a，T2 b)函数。

这种方式的优点是我们不必显式地指定类型！

这使得编写简短的代码更加容易！看上面相同的例子，现在使用std :: make_pair()重写。

#include <iostream>
#include <string>

int main() {
  auto my_pair = std::make_pair(1, "Hello");

  std::cout << "First element : " << my_pair.first << std::endl;
  std::cout << "Second element : " << my_pair.second << std::endl;
  return 0;
}

我从来没有在这里提到类型名称。
auto和make_pair()为我们完成了这项工作！

First element : 1
Second element : Hello

现在让我们看看我们可以使用此容器类执行的其他操作！

std :: pair的默认运算符

我们将研究如何使用逻辑运算符比较两个" std :: pair"变量。

• 如果我们想使用" ="将对分配给另一个对变量，则将第一对的第一个值分配给第二对的第一个值。
  (与第二个元素相同)

• "！="运算符比较第一个和第二个元素，并且仅当其中任何一个不相等时才返回True。

• 同样，==运算符也进行相应的比较。

• " <="和"> ="运算符首先检查两个对的前两个元素，然后返回比较。
  如果它们相等，则比较第二个元素。

为了说明所有这些运算符，一个简单的示例可能很容易可视化。

#include <iostream> 

int main() 
{ 
  std::pair<int, int>pair1 = make_pair(10, 12); 
  std::pair<int, int>pair2 = make_pair(10, 14); 

  std::cout << (pair1 == pair2) << std::endl; 
  std::cout << (pair1 != pair2) << std::endl; 
  std::cout << (pair1 >= pair2) << std::endl; 
  std::cout << (pair1 <= pair2) << std::endl; 

  return 0; 
} 

输出

0
1
0
1

用std :: pair重载运算符

我们可以在std :: pair上直接重载某些特定的运算符。

以下运算符可以在C++ 20中重载。

• 运算子==
• 运算符<=>

请注意：在C++ 20中，除==外的所有逻辑运算符都不能重载。
与C++ 17相比，这是一个重大更改。

让我们举一个重载逻辑等于运算符(==)的示例。

我们将对此进行重载以比较一对值。
为了相等，第一个和第二个值必须匹配。

template <typename T1, typename T2>
bool operator== (std::pair <T1, T2> &p, std::pair <T1, T2> &q) {
  if (p.first == q.first && p.second == q.second) {
      std::cout << "Equal\n";
      return true;
  }
  std::cout << "Not Equal\n";
  return false;
}

完整的代码如下所示：

#include <iostream>
#include <string>

template <typename T1, typename T2>
bool operator== (std::pair <T1, T2> &p, std::pair <T1, T2> &q) {
  if (p.first == q.first && p.second == q.second) {
      std::cout << "Equal\n";
      return true;
  }
  std::cout << "Not Equal\n";
  return false;
}

int main() {
  auto p = std::make_pair(1, "Hello");
  auto q = std::make_pair(1, "Hello");

  if (p == q) {
      printf("True\n");
  }
  else {
      printf("False\n");
  }

  auto r = std::make_pair(1, "Hello");
  auto s = std::make_pair(1, "theitroad");

  if (r == s) {
      printf("True\n");
  }
  else {
      printf("False\n");
  }
  return 0;
}

输出

Equal
True
Not Equal
False

如您所见，我们确实已经使==运算符超载，以使其也可以用于std :: pair！