C++ 中的二维向量对与示例

什么是向量？

在 C++ 中，向量类似于动态数组，具有自动调整自身大小的能力。向量元素存储在连续的内存位置，以便可以使用迭代器访问和遍历它们。

与向量相关的一些函数：

• begin() ：返回一个指向向量中第一个元素的迭代器
• end() ：返回一个迭代器，指向向量中最后一个元素之后的理论元素
• rbegin() ：返回一个反向迭代器，指向向量中的最后一个元素（反向开始）。它从最后一个元素移动到第一个元素
• size() ：返回向量中的元素数。
• empty() ：返回向量是否为空。
• push_back() ：它将元素从后面推入一个向量
• pop_back() ：它用于从后面的向量中弹出或删除元素。
• insert() ：在指定位置的元素之前插入新元素

什么是二维向量？

在 C++ 中，2D 向量是向量的向量，这意味着 2D 向量的每个元素都是向量本身。它与借助向量实现的矩阵相同。

与二维向量相关的一些函数：

• size()：返回二维向量中的元素个数。
• empty()：返回二维向量是否为空。
• push_back()：它将一个向量从后面推入一个二维向量。
• pop_back()：用于从 2D 向量的背面弹出或删除元素。

什么是配对？

C++ 中的实用程序标头为我们提供了配对容器。一对由两个数据元素或对象组成。

• 第一个元素被称为“第一”，第二个元素被称为“第二”，并且顺序是固定的（第一，第二）。
• Pair 用于将类型可能不同的两个值组合在一起。 Pair 提供了一种将两个异构对象存储为一个单元的方法。
• 可以分配、复制和比较对。在 map 或 hash_map 中分配的对象数组默认为“pair”类型，其中所有“first”元素都是与其“second”值对象关联的唯一键。
• 要访问元素，我们使用变量名后跟点运算符，然后是关键字 first 或 second。

如何访问一对？

要访问一对元素，请使用点 (.)运算符。

句法：

auto fistElement = myPair.first;

auto fistElement = myPair.second;

二维向量对

二维向量对或向量对向量是一个向量，其中每个元素都是对本身的向量。

句法：

vector> myContainer

Here,

dataType1 and dataType2 can be similar or dissimilar data types.

示例 1：在下面的 C++ 程序中，使用了类型为 {int, 字符串} 的向量对的向量。

C++

// C++ program to demonstrate the 
// working of vector of vectors 
// of pairs
#include 
using namespace std;
  
// Function to print 2D vector elements
void print(vector>> &myContainer)
{
  // Iterating over 2D vector elements
  for(auto currentVector: myContainer)
  {
    // Each element of the 2D vector 
    // is a vector itself
    vector> myVector = 
           currentVector;
  
    // Iterating over the the vector 
    // elements
    cout << "[  ";
    for(auto pr: myVector)
    {
      // Print the element
      cout << "{";
      cout << pr.first << " , " << 
              pr.second;
      cout << "}  ";
    } 
  
    cout << "]\n";
  }
}
  
// Driver code
int main() 
{
  // Declaring a 2D vector of pairs
  vector>> myContainer;
  
  // Initializing vectors of pairs
  // Pairs are of type {int, string}
  vector> vect1 = 
  {{0, "GeeksforGeeks"}, {1, "GFG"}, 
   {2, "Computer Science"}};
  vector> vect2 = 
  {{0, "C#"}, {1, "C"}, {2, "C++"}};
  vector> vect3 = 
  {{0, "HTML"}, {1, "CSS"}, 
   {2, "Javascript"}};
  vector> vect4 = 
  {{0, "R"}, {1, "Swift"}, 
   {2, "Python"}};
  
  // Inserting vectors in the 
  // 2D vector
  myContainer.push_back(vect1);
  myContainer.push_back(vect2);
  myContainer.push_back(vect3);
  myContainer.push_back(vect4);
  
  // Calling print function
  print(myContainer);
  
  return 0;
}

输出：

[  {0 , GeeksforGeeks}  {1 , GFG}  {2 , Computer Science}  ]
[  {0 , C#}  {1 , C}  {2 , C++}  ]
[  {0 , HTML}  {1 , CSS}  {2 , Javascript}  ]
[  {0 , R}  {1 , Swift}  {2 , Python}  ]

示例 2：在下面的 C++ 程序中，使用了类型为 {char, bool} 的向量对的向量。

C++

// C++ program to demonstrate the 
// working of vector of vectors 
// of pairs
#include 
using namespace std;
  
// Function to print 2D vector elements
void print(vector>> &myContainer)
{
  // Iterating over 2D vector elements
  for(auto currentVector: myContainer)
  {
    // Each element of the 2D vector is 
    // a vector itself
    vector> myVector = 
           currentVector;
  
    // Iterating over the the vector 
    // elements
    cout << "[  ";
    for(auto pr: myVector)
    {
      // Print the element
      cout << "{";
      cout << pr.first << " , " << 
              pr.second;
      cout << "}  ";
    } 
  
    cout << "]\n";
  }
}
  
// Driver code
int main() 
{
  // Declaring a 2D vector of pairs
  // Pairs are of type {char, bool}
  vector>> myContainer;
  
  // Initializing vectors of pairs
  vector> vect1 = 
  {{'G', 0}, {'e', 0}, 
   {'e', 0}, {'k', 0}};
  vector> vect2 = 
  {{'G', 1}, {'e', 1}, 
   {'e', 1}, {'k', 1}};
  vector> vect3 = 
  {{'G', 0}, {'e', 0}, 
   {'e', 0}, {'k', 1}};
  vector> vect4 = 
  {{'G', 0}, {'e', 1}, 
   {'e', 0}, {'k', 1}};
  
  // Inserting vectors in the 2D vector
  myContainer.push_back(vect1);
  myContainer.push_back(vect2);
  myContainer.push_back(vect3);
  myContainer.push_back(vect4);
  
  print(myContainer);
  
  return 0;
}

输出：

[  {G , 0}  {e , 0}  {e , 0}  {k , 0}  ]
[  {G , 1}  {e , 1}  {e , 1}  {k , 1}  ]
[  {G , 0}  {e , 0}  {e , 0}  {k , 1}  ]
[  {G , 0}  {e , 1}  {e , 0}  {k , 1}  ]