Multimapa de pares en C++ con ejemplos

¿Qué es un multimapa?

En C++ , un mapa múltiple es un contenedor asociativo que se usa para almacenar elementos en forma de mapa. Internamente, un mapa múltiple se implementa como un árbol rojo-negro . Cada elemento de un mapa múltiple se trata como un par. El primer valor se denomina clave y el segundo valor se denomina valor. Multimapa es bastante similar a un mapa, pero en el caso de un multimapa, podemos tener varias claves iguales. Además, no podemos usar corchetes ([]) para acceder al valor asignado con una clave. Al igual que un mapa, las claves del mapa múltiple se ordenan en orden ascendente de forma predeterminada.

Funciones asociadas a multimapa:

• begin() : Devuelve un iterador al primer elemento en el mapa múltiple
• end() : Devuelve un iterador al elemento teórico que sigue al último elemento en el mapa múltiple
• size() : Devuelve el número de elementos en el mapa múltiple
• max_size() : Devuelve el número máximo de elementos que el mapa múltiple puede contener
• vacío() : devuelve si el multimapa está vacío
• insert(key, value) : Agrega un nuevo elemento o par al mapa múltiple
• erase(posición del iterador) : Elimina el elemento en la posición señalada por el iterador
• erase(const x) : Elimina el valor-clave ‘x’ del mapa múltiple
• clear() : Elimina todos los elementos del mapa múltiple

¿Qué es un par?

El encabezado de utilidad en C++ nos proporciona un contenedor de pares . Un par consta de dos elementos de datos u objetos.

• Se hace referencia al primer elemento como ‘primero’ y al segundo elemento como ‘segundo’ y el orden es fijo (primero, segundo).
• Par se utiliza para combinar dos valores que pueden ser de tipo diferente. Pair proporciona una forma de almacenar dos objetos heterogéneos como una sola unidad.
• El par se puede asignar, copiar y comparar. La array de objetos asignados en un mapa o hash_map es de tipo ‘par’ por defecto en el que todos los ‘primeros’ elementos son claves únicas asociadas con sus ‘segundos’ objetos de valor.

Para acceder a los elementos, usamos el nombre de la variable seguido del operador de punto seguido de la palabra clave primero o segundo.

¿Cómo acceder a un par?

Se puede acceder a los elementos de un par usando el operador de punto (.).

Sintaxis:

auto fistElement = miPar.primero;

auto fistElement = miPar.segundo;

Multimapa de pares

Un mapa múltiple de pares es un mapa múltiple en el que la clave o el valor es un par en sí mismo. Se considera que dos pares son iguales si el primero y el segundo elementos correspondientes de los pares son iguales. Ahora, si es necesario almacenar más de una copia de un par junto con otros elementos que también están ordenados o en un orden particular, en tales casos, el conjunto múltiple de pares resulta útil.

Sintaxis:

multimap<par<tipo de datos1, tipo de datos2>> myMultimap;

Aquí,

dataType1 y dataType2 pueden ser tipos de datos similares o diferentes.

Ejemplo 1: A continuación se muestra el programa C++ para demostrar el funcionamiento de un mapa múltiple de pares. 

// C++ program to demonstrate
// the working of a multimap of
// pairs.
#include <bits/stdc++.h>
using namespace std;
  
// Function to print multimap elements
void print(multimap<pair<int, int>, 
           bool>& myContainer)
{
    cout << "Key(pair of integers)" << 
            "            " << 
            "Value(boolean)\n\n";
  
    for (auto pr : myContainer)  
    {
        pair<int, int> myPair = pr.first;
  
        // pr points to current pair of myContainer
        cout << '[' << myPair.first << " , " << 
                myPair.second << ']' << 
                "                                 " << 
                pr.second << '\n';
    }
}
  
// Driver code
int main()
{
    // Declaring a multimap
    // Key is of pair<int, int> type
    // Value is of bool type
    multimap<pair<int, int>, bool> myContainer;
  
    // Creating some pairs to be used
    // as keys
    pair<int, int> pair1;
    pair1 = make_pair(100, 200);
  
    pair<int, int> pair2;
    pair2 = make_pair(200, 300);
  
    pair<int, int> pair3;
    pair3 = make_pair(300, 400);
  
    pair<int, int> pair4;
    pair4 = make_pair(100, 200);
  
    // Since each element is a pair on 
    // its own in a multimap. So, we 
    // are inserting a pair
    // Note that [] operator doesn't working 
    // in case of a multimap
    myContainer.insert(pair<pair<int, int>, 
                       bool>(pair1, true));
    myContainer.insert(pair<pair<int, int>, 
                       bool>(pair2, false));
    myContainer.insert(pair<pair<int, int>, 
                       bool>(pair3, true));
    myContainer.insert(pair<pair<int, int>, 
                       bool>(pair4, false));
  
    // Calling print function
    print(myContainer);
  
    return 0;
}

Ejemplo 2: A continuación se muestra el programa C++ para demostrar el funcionamiento de un mapa múltiple de pares.

// C++ program to demonstrate
// the working of a multimap of
// pairs.
#include <bits/stdc++.h>
using namespace std;
  
// Function to print multimap elements
void print(multimap<pair<string, int>, 
           bool>& myContainer)
{
    cout << "Key(pair of integers)" << 
            "            " << 
            "Value(boolean)\n\n";
  
    for (auto pr : myContainer) 
    {
        pair<string, int> myPair = pr.first;
  
        // pr points to current pair of myContainer
        cout << '[' << myPair.first << 
                " , " << myPair.second << 
                ']' << "                " << 
                "                 " << 
                pr.second << '\n';
    }
}
  
// Driver code
int main()
{
    // Declaring a multimap
    // Key is of pair<int, int> type
    // Value is of bool type
    multimap<pair<string, int>, bool> myContainer;
  
    // Creating some pairs to be used
    // as keys
    pair<string, int> pair1;
    pair1 = make_pair("GFG", 100);
  
    pair<string, int> pair2;
    pair2 = make_pair("C++", 200);
  
    pair<string, int> pair3;
    pair3 = make_pair("CSS", 300);
  
    pair<string, int> pair4;
    pair4 = make_pair("GFG", 400);
  
    // Since each element is a pair on its 
    // own in a multimap. So, we are 
    // inserting a pair
    // Note that [] operator doesn't working 
    // in case of a multimap
    myContainer.insert(pair<pair<string, int>, 
                       bool>(pair1, true));
    myContainer.insert(pair<pair<string, int>, 
                       bool>(pair2, false));
    myContainer.insert(pair<pair<string, int>, 
                       bool>(pair3, true));
    myContainer.insert(pair<pair<string, int>, 
                       bool>(pair4, false));
  
    // Calling print function
    print(myContainer);
  
    return 0;
}