Priority_queue emplace() en C++ STL

Las colas de prioridad son un tipo de adaptadores de contenedores, diseñados específicamente para que el primer elemento de la cola sea el más grande o el más pequeño de todos los elementos de la cola. Sin embargo, en C++ STL (de manera predeterminada), el elemento más grande está en la parte superior. También podemos crear una cola de prioridad que tenga el elemento más pequeño en la parte superior simplemente pasando un parámetro adicional al crear la cola de prioridad.

Esta función se usa para insertar un nuevo elemento en el contenedor de la cola de prioridad, el nuevo elemento se agrega a la cola de prioridad de acuerdo con su prioridad. Es similar a la operación de empuje. La diferencia es que la operación emplace() guarda una copia innecesaria del objeto.

Complejidad del tiempo: O(log n)

Sintaxis:  

priorityqueuename.emplace(value)
Parameters :
The element to be inserted into the priority
queue is passed as the parameter.
Result :
The parameter is added to the
priority queue at the top position.

Ejemplos: 

Input  : mypqueue{5, 4};
         mypqueue.emplace(6);
Output : mypqueue = 6, 5, 4

Input  : mypqueue{};
         mypqueue.emplace(4);
Output : mypqueue = 4

Nota: En el contenedor de la cola de prioridad, los elementos se imprimen en orden inverso porque la parte superior se imprime primero y luego se pasa a otros elementos.

Errores y excepciones 
1. Tiene una fuerte garantía de excepción, por lo tanto, no se realizan cambios si se lanza una excepción. 
2. El parámetro debe ser del mismo tipo que el del contenedor; de lo contrario, se genera un error.

// INTEGER PRIORITY QUEUE
// CPP program to illustrate
// Implementation of emplace() function
#include <iostream>
#include <queue>
using namespace std;
 
int main()
{
    priority_queue<int> mypqueue;
    mypqueue.emplace(1);
    mypqueue.emplace(2);
    mypqueue.emplace(3);
    mypqueue.emplace(4);
    mypqueue.emplace(5);
    mypqueue.emplace(6);
    // queue becomes 1, 2, 3, 4, 5, 6
 
    // printing the priority queue
    cout << "mypqueue = ";
    while (!mypqueue.empty()) {
        cout << mypqueue.top() << " ";
        mypqueue.pop();
    }
 
    return 0;
}

mypqueue = 6 5 4 3 2 1 

// CHARACTER PRIORITY QUEUE
// CPP program to illustrate
// Implementation of emplace() function
#include <iostream>
#include <queue>
using namespace std;
 
int main()
{
    priority_queue<char> mypqueue;
    mypqueue.emplace('A');
    mypqueue.emplace('b');
    mypqueue.emplace('C');
    mypqueue.emplace('d');
    mypqueue.emplace('E');
    mypqueue.emplace('f');
    // queue becomes A, b, C, d, E, f
 
    // printing the priority queue
    cout << "mypqueue = ";
    while (!mypqueue.empty()) {
        cout << mypqueue.top() << " ";
        mypqueue.pop();
    }
 
    return 0;
}

mypqueue = f d b E C A 

// STRING PRIORITY QUEUE
// CPP program to illustrate
// Implementation of emplace() function
#include <iostream>
#include <queue>
#include <string>
using namespace std;
 
int main()
{
    priority_queue<string> mypqueue;
    mypqueue.emplace("portal");
    mypqueue.emplace("computer science");
    mypqueue.emplace("is a");
    mypqueue.emplace("GEEKSFORGEEKS");
    // queue becomes portal, computer science,
    // is a, GEEKSFORGEEKS
 
    // printing the priority queue
    cout << "mypqueue = ";
    while (!mypqueue.empty()) {
        cout << mypqueue.top() << " ";
        mypqueue.pop();
    }
 
    return 0;
}

mypqueue = portal is a computer science GEEKSFORGEEKS 

Aplicación: 
Dada una cantidad de enteros, agréguelos a la cola de prioridad usando emplace() y encuentre el tamaño de la cola de prioridad. 

Input : 5, 13, 0, 9, 4
Output: 5

Algoritmo 
1. Inserte los elementos dados en el contenedor de la cola de prioridad uno por uno usando emplace(). 
2. Siga sacando los elementos de la cola de prioridad hasta que se vacíe e incremente la variable contador. 
3. Imprima la variable de contador.

// CPP program to illustrate
// Application of emplace() function
#include <iostream>
#include <queue>
using namespace std;
 
int main()
{
    int c = 0;
 
    // Empty Priority Queue
    priority_queue<int> pqueue;
 
    // inserting elements into priority_queue
    pqueue.emplace(5);
    pqueue.emplace(13);
    pqueue.emplace(0);
    pqueue.emplace(9);
    pqueue.emplace(4);
 
    // Priority queue becomes 13, 9, 5, 4, 0
 
    // Counting number of elements in queue
    while (!pqueue.empty()) {
        pqueue.pop();
        c++;
    }
    cout << c;
}

5

emplace() vs push() 
Cuando usamos push(), creamos un objeto y luego lo insertamos en la cola de prioridad. Con emplace(), el objeto se construye en el lugar y guarda una copia innecesaria. Consulte emplace vs insert en C++ STL para obtener más detalles.

// C++ code to demonstrate difference between
// emplace and insert
#include<bits/stdc++.h>
using namespace std;
   
int main()
{
    // declaring priority queue
    priority_queue<pair<char, int>> pqueue;
       
    // using emplace() to insert pair in-place
    pqueue.emplace('a', 24);
       
    // Below line would not compile
    // pqueue.push('b', 25);   
       
    // using push() to insert pair
    pqueue.push(make_pair('b', 25));   
       
    // printing the priority_queue
    while (!pqueue.empty()) {
        pair<char, int> p =  pqueue.top();
        cout << p.first << " "
             << p.second << endl;
        pqueue.pop();
    }
   
    return 0;
}

b 25
a 24