Multimapa de tuplas 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, uno puede tener varias claves iguales. Además, no se pueden 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 puede contener el mapa múltiple.
• empty() : Devuelve si el mapa múltiple 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 una Tupla?

Una tupla en C++ es un objeto que se utiliza para agrupar elementos. En una tupla, los elementos pueden ser del mismo tipo de datos o diferentes tipos de datos. Los elementos de las tuplas se inicializan en el orden en que se accederá a ellos.

Funciones asociadas a una tupla:

• make_tuple(): Se utiliza para asignar tuplas con valores. Los valores pasados ​​deben estar en orden con los valores declarados en la tupla.
• get(): Se utiliza para acceder a los valores de la tupla y modificarlos, acepta el índice y el nombre de la tupla como argumentos para acceder a un elemento de la tupla en particular.

¿Cómo acceder a una Tupla?

Para acceder a los elementos de una tupla, utilice la función get<>().

Sintaxis:

auto fistElement = get<0>(myTuple);

auto secondElement = get<1>(myTuple);

auto tercerElemento = get<2>(myTuple);

Este artículo se centra en cómo crear un mapa múltiple de tuplas en C++.

Multimapa de tuplas

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

Sintaxis:

multimapa<tuplas<tipo de datos1, tipo de datos2, tipo de datos3>> myMultimap;

Aquí,

dataType1, dataType2, dataType3 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 tuplas.

// C++ program to demonstrate
// the working of a multimap of
// tuples.
#include <bits/stdc++.h>
using namespace std;
  
// Function to print multimap elements
void print(multimap<tuple<int, int, int>, 
           bool>& myContainer)
{
    cout << "Key(tuple of integers)" << 
            "            " << 
            "Value(boolean)\n\n";
  
    for (auto currentTuple : myContainer) 
    {
        // Each element of the multiset is 
        // a pair on its own Key is of type tuple
        tuple<int, int, int> Key = currentTuple.first;
  
        // Value is a boolean value
        bool value = currentTuple.second;
  
        // Print key elements and value
        cout << '[' << get<0>(Key) << " , " << 
                get<1>(Key) << " , " << get<2>(Key) << 
                ']' << "                        " << 
                value << '\n';
    }
}
  
// Driver code
int main()
{
    // Declaring a multimap
    // Key is of tuple<int, int, int> type
    // Value is of bool type
    multimap<tuple<int, int, int>, 
             bool> myContainer;
  
    // Creating some tuples to be used
    // as keys
    tuple<int, int, int> tuple1;
    tuple1 = make_tuple(100, 200, 300);
  
    tuple<int, int, int> tuple2;
    tuple2 = make_tuple(200, 300, 400);
  
    tuple<int, int, int> tuple3;
    tuple3 = make_tuple(300, 400, 500);
  
    tuple<int, int, int> tuple4;
    tuple4 = make_tuple(100, 200, 300);
  
    // Since each element is a tuple on its 
    // own in a multimap. So, we are inserting 
    // a tuple
    // Note that [] operator doesn't working 
    // in case of a multimap
    myContainer.insert(pair<tuple<int, int, int>, 
                       bool>(tuple1, true));
    myContainer.insert(pair<tuple<int, int, int>, 
                       bool>(tuple2, false));
    myContainer.insert(pair<tuple<int, int, int>, 
                       bool>(tuple3, true));
    myContainer.insert(pair<tuple<int, int, int>, 
                       bool>(tuple4, 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 tuplas.

// C++ program to demonstrate
// the working of a multimap of
// tuples.
#include <bits/stdc++.h>
using namespace std;
  
// Function to print multimap elements
void print(multimap<tuple<string, int, float>, 
           bool>& myContainer)
{
    cout << "Key(tuple of integers)" << 
            "            " << 
            "Value(boolean)\n\n";
  
    for (auto currentTuple : myContainer) 
    {
        // Each element of the multiset is 
        // a tuple on its own
        // Key is of type tuple
        tuple<string, int, float> Key = 
                           currentTuple.first;
  
        // Value is a boolean value
        bool value = currentTuple.second;
  
        // Print key elements and value
        cout << '[' << get<0>(Key) << " , " << 
                get<1>(Key) << " , " << get<2>(Key) << 
                ']' << "                        " << 
                value << '\n';
    }
}
  
// Driver code
int main()
{
    // Declaring a multimap
    // Key is of tuple<string, int, 
    // float> type
    // Value is of bool type
    multimap<tuple<string, int, float>, 
                           bool> myContainer;
  
    // Creating some tuples to be used
    // as keys
    tuple<string, int, float> tuple1;
    tuple1 = make_tuple("Java", 100, 1.123);
  
    tuple<string, int, float> tuple2;
    tuple2 = make_tuple("Geek", 200, 2.123);
  
    tuple<string, int, float> tuple3;
    tuple3 = make_tuple("HTML", 300, 3.123);
  
    tuple<string, int, float> tuple4;
    tuple4 = make_tuple("Java", 100, 1.123);
  
    // Since each element is a tuple on its 
    // own in the multimap. So, we are 
    // inserting a tuple
    // Note that [] operator doesn't working 
    // in case of a multimap
    myContainer.insert(pair<tuple<string, int, float>, 
                       bool>(tuple1, true));
    myContainer.insert(pair<tuple<string, int, float>, 
                       bool>(tuple2, false));
    myContainer.insert(pair<tuple<string, int, float>, 
                       bool>(tuple3, true));
    myContainer.insert(pair<tuple<string, int, float>, 
                       bool>(tuple4, false));
  
    // Calling print function
    print(myContainer);
  
    return 0;
}