Ejercicios de Colas utilizando clase Cola creada a partir de la librería Queue

#include <iostream>
#include <queue> //cola

using namespace std;


/**
* Crearemos la clase Cola a partir de la librería QUEUE de C++
*/
template <class Tipo>
class Cola : private queue<Tipo> {
public:
    Tipo extraer(){
        Tipo valor = this->front();
        this->pop();
        return valor;
    }

    void agregar(Tipo valor){
        this->push(valor);
    }

    bool vacia(){
        return this->empty();
    }
};


/**Función para crear datos de prueba **/
void crearCola(Cola<int> &c, int cantidad){
    for(int i=0; i<cantidad; i++)
        c.agregar(rand()%100);
}

/** muestra la cola por pantalla, al terminar la cola queda vacía
1) void imprimeCola(Cola) */
void imprimeCola(Cola<int> &c){
    while(!c.vacia())
        cout<<c.extraer()<<endl;
}

/** muestra la cola por pantalla, al terminar la cola queda intacta
2) void muestraCola(Cola) */
void mostrarCola(Cola<int> c){
    while(!c.vacia())
        cout<<c.extraer()<<endl;
}

/** muestra la cola por pantalla, al terminar la cola queda intacta utilizando templates
3) void mostrarColaT(Cola<Tipo>) */
template <class Tipo>
void mostrarColaT(Cola<Tipo> c){
    while(!c.vacia())
        cout<<c.extraer()<<endl;
}

/** muestra la cola por pantalla, al terminar la cola queda intacta utilizando recursividad
4) void mostrarRecursivo(Cola<Tipo>) */
void mostrarRecursivo(Cola<int> c){
    if(c.vacia())
       return ;
    cout<<c.extraer()<<endl;
    mostrarRecursivo(c);
}

/** muestra la cola de forma inversa por pantalla, al terminar la cola queda intacta utilizando recursividad
5) void mostrarRecursivoInverso(Cola<Tipo>) */
void mostrarRecursivoInverso(Cola<int> c){
    if(c.vacia())
       return ;
    int aux=c.extraer();
    mostrarRecursivoInverso(c);
    cout<<aux<<endl;
}

/** contar elementos dentro de la cola
6) int contarElementosEnLaCola(Cola) **/
int contarElementosEnLaCola(Cola<int> c){
    int contador=0;
    while(!c.vacia()){
        c.extraer();
        contador++;
    }
    return contador;
}

/** sumar elementos dentro de la cola, sólo ejecutarlo con enteros
7) int sumarElementos(Cola<int>) **/
int sumarElementosCola(Cola<int> c){
    int suma=0;
    while(!c.vacia()){
        suma+=c.extraer();
    }
    return suma;
}

/** invierte el orden de los elementos de la cola, tip: use recursividad
8) void invertirCola(Cola) */
void invertirCola(Cola<int> &c){
    if(c.vacia())
       return ;
    int aux=c.extraer();
    invertirCola(c);
    c.agregar(aux);
}


/** retorna la posición del elemento dentro de la cola, de no encontrarlo devuelve -1
9) bool posicionElemento(Cola<Tipo>, int)  **/
int posicionElemento(Cola<int> c, int elemento){
    int contador=0;
    while(!c.vacia()){
        contador++;
        if(c.extraer() == elemento)
            return contador;
    }
    return -1;
}

/** elimina de la cola el elemento que esta en la ubicacion, los otros elementos quedan en el mismo orden
10) void eliminaElementoPorUbicacion(Cola pajar, int ubicacion) */
int eliminaElementoPorUbicacion(Cola<int> c, int elemento){
    int contador=0;
    while(!c.vacia()){
        contador++;
        if(c.extraer() == elemento)
            return contador;
    }
    return -1;
}



/** elimina todos los elementos de la cola
11) void eliminacionCola(Cola) */
void eliminacionCola(Cola<int> &c){
    while(!c.vacia())
        c.extraer();
}

/** elimina el elemento que se encuentra en la posición indicada
12) void eliminacionPosicionX(Cola<int>, int posX) */
void eliminacionPosicionX(Cola<int> &c, int posx){
    int posicion=0;
    Cola<int> auxiliar;
    while(!c.vacia()){
        posicion++;
        if(posicion != posx)
            auxiliar.agregar(c.extraer());
        else
            c.extraer();
    }
    while(!auxiliar.vacia())
        c.agregar(auxiliar.extraer());
}

/** retorne true si el elemento existe en la cola
13) void existeElemento(Cola, int) */
bool existeElemento(Cola<int> c, int elemento){
    while(!c.vacia()){
        if(c.extraer() == elemento)
            return true;
    }
    return false;
}


/** retornar el último elemento de la cola (usar templates)
14) Tipo ultimoElemento(Cola<Tipo>) */
int ultimoElemento(Cola<int> c){
    int ultimo=-1;
    while(!c.vacia()){
        ultimo=c.extraer();
    }
    return ultimo;
}



/** copia la cola de origen a destino *
15) void copiarCola(Cola origen, Cola destino) */
void copiarCola(Cola<int> &origen, Cola<int> &destino){
    Cola<int> aux;
    //lo guardo en una aux
    while(!origen.vacia())
        aux.agregar(origen.extraer());

    //colocar el dato en ambas colas
    while(!aux.vacia()){
        int tmp =aux.extraer();
        origen.agregar(tmp);
        destino.agregar(tmp);
    }
}


/** copia la cola de origen a destino, pero lo hace utilizando templates *
16) void copiarCola(Cola origen, Cola destino) */
template <class Tipo>
void copiarColaTemplate(Cola<Tipo> &origen, Cola<Tipo> &destino){
    Cola<Tipo> aux;
    //lo guardo en una aux
    while(!origen.vacia())
        aux.agregar(origen.extraer());

    //colocar el dato en ambas colas
    while(!aux.vacia()){
        Tipo tmp =aux.extraer();
        origen.agregar(tmp);
        destino.agregar(tmp);
    }
}


int main()
{
    Cola<int> c;
    int cant=10;
    crearCola(c,cant);
    mostrarCola(c);
    cout<<"Cantidad de elementos: "<<contarElementosEnLaCola(c)<<endl;
    cout<<"La suma total es: "<<sumarElementosCola(c)<<endl;
    mostrarCola(c);
    cout<<"\t[MOSTRAR RECURSIVO]"<<endl;
    mostrarRecursivo(c);

    cout<<"INVERSO"<<endl;
    mostrarRecursivoInverso(c);

    cout<<"invertir cola"<<endl;
    invertirCola(c);
    mostrarCola(c);
    cout<<"Posicion elemento x"<<posicionElemento(c,41)<<endl;
    cout<<"Posicion elemento x"<<posicionElemento(c,100)<<endl;

    cout<<"Eliminacion"<<endl;
    eliminaElementoPorUbicacion(c,1);
    eliminaElementoPorUbicacion(c,1);
    eliminaElementoPorUbicacion(c,1);
    mostrarCola(c);

    if(existeElemento(c,34)){
        cout<<"Existe"<<endl;
    }else
        cout<<"No existe"<<endl;

    cout<<"Ultimo elemento: "<<ultimoElemento(c);
    return 0;
}