20201106 Utilización simple de la clase Stack y stack STL

#include <iostream>

using namespace std;


/*****************************CLASE STACK **********************/
#include <stack>
template <class Tipo>
class Stack : private stack<Tipo> {
public:
    void push(Tipo t){
        stack<Tipo>::push(t);
    }

    Tipo pop(){
        Tipo temp = stack<Tipo>::top();
        stack<Tipo>::pop();
        return temp;
    }

    bool empty(){
        return stack<Tipo>::empty();
    }
};

/**********************Funciones utilizando STACK*************************/
//mostrar los datos de un stack
void mostrar(Stack<int> s){
    cout <<"[mostrando]"<<endl;
    while(!s.empty())
        cout << s.pop()<<endl;
}

/**2) contar(S): Función que retorna el número de elementos que contienen el stack S.***/
int contarSimple(Stack<int> s){
    int cont=0;
    while(!s.empty()){
        s.pop();
        cont++;
    }
    return cont;
}

/*contar los datos de un stack, pero pasamos la variable por referencia,
acá tendremos que guardar los datos en un auxiliar y luego devolverlos al stack original */

int contar(Stack<int> &s){
    int cont=0;
    //guardamos
    Stack<int> tmp;
    while(!s.empty()){
        int aux = s.pop();
        tmp.push(aux); //copia
        cont++;
    }

    //devolver al original
    while(!tmp.empty())
        s.push(tmp.pop());
    return cont;
}

/**3) sumar(S): Función que retorna la suma de los elementos del stack S.**/
int sumar(Stack<int> s){
    int suma=0;
    while(!s.empty())
        suma+=s.pop();
    return suma;
}

/**4) botton(S): Función que retorna el elemento que está ubicado
en el fondo (el primero que entró) del stack S. */
int ultimoElemento(Stack<int> s){
    int ultimo=-1;
    while(!s.empty()){
        ultimo=s.pop();
    }
    return ultimo;
}

/**5) posK(S,k): Función que retorna el elemento que se ubica en
la posición k (para salir) del stack S. **/

int retornaK(Stack<int> s, int k){
    int c=1, t;
    Stack<int> aux;
    //Pasar desde s a un aux
    while(!s.empty())
        aux.push(s.pop());

    //Ahora revisamos el aux para comparar k
    while(!aux.empty()){
        t = aux.pop();
        if(c==k)
            return t;
        c++;
    }
    return -1;
}

int main()
{
    //Parte 1 de la clase: Utilizando el stack de forma nativa para c++
    stack<int> s;
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);

    //mostramos la información del stack (primero en entrar es el último en salir)
    while(!s.empty()) {
        cout << s.top(); //obtenemos el dato
        s.pop(); //eliminamos el dato
    }

    //parte 2 de la clase: Utilizando funciones Stack
    Stack<int> s1;
    s1.push(1001);
    s1.push(1002);
    s1.push(1003);
    s1.push(1004);
    s1.push(1005);

    mostrar(s1);
    cout<<contar(s1)<<endl;
    mostrar(s1);
    cout<<sumar(s1)<<endl;
    cout<<"ultimo:"<<ultimoElemento(s1)<<endl;
    cout<<"elemento en posición k:"<<retornaK(s1,2)<<endl;

    return 0;
}