20201117 Ejercicio de aplicación de Stack+Colas+Heap (por completar)

#include <iostream>

using namespace std;

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

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

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

/**
* Crearemos la clase Cola a partir de la librería QUEUE de C++
*/
#include <queue>
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();
    }
};

/************************************************************/
#ifndef HEAPTEMPLATE_H
#define HEAPTEMPLATE_H

#include <queue>
template <class T> class Heap {
public:
    Heap() {};
    virtual ~Heap() {};

    void agregar(T dato, int prioridad) {
        ParPrioridadDato par;
        par.first = prioridad;
        par.second= dato;
        h2.push(par);
    };

    T extraer(){
        ParPrioridadDato par = h2.top();
        h2.pop();
        return par.second;
    }

    bool vacia() {
        return h2.empty();
    }

private:
    typedef std::pair<int, T> ParPrioridadDato; // Prioridad, orden

    class ComparePrioridad {
        public:
            bool operator() (ParPrioridadDato a, ParPrioridadDato b) {
                return a.first > b.first;
            }
    };
    std::priority_queue<ParPrioridadDato, std::vector<ParPrioridadDato>, ComparePrioridad> h2;
};


#endif // HEAPTEMPLATE_H





/***********************************************************************************************/

/**
Caso: Tienda de calcetines “La esquina del calcetín”
Mi suega tiene una tienda de calcetines de marca, pero no solo tiene calcetines (textura),
sino que también tiene boxer(tamaño: s m l xl), pañuelos (motivo), poleras(color), pijamas(largo).
** se conoce su precio, fecha de ingreso AAAAMMDD y su descripción.
Los productos vienen en cajas y se puede sacar primero el último que ingresaron a la caja.
Se necesita organizar los calcetines por fecha de ingreso, para que los más antiguos sean
los primeros en ofrecerse a los clientes.
>>mostrar y dejar en una estructura en que el primero en llegar es el primero en salir
Llega un cliente difícil y pide ver el calcetín más caro y el más económico.
>>retornar esos calcetines al cliente y mostrar la información.

La tienda tiene una bodega estrecha y larga, por lo que los productos se deberán ir
ingresando en este orden: calcetines, poleras boxer.
>>la bodega puede almacenar todo tipo de productos.
Finalmente necesito conocer el total de dinero que tengo al sumar todos los productos
almacenados en la bodega.
**/

class Ropa{
public:
    Ropa(){};
    Ropa(int p,int f, string d):precio(p), fecha(f), descripcion(d) {
    };

    int getFecha(){
        return fecha;
    }

    int getPrecio(){
        return precio;
    }
protected:
    int precio;
    int fecha;
    string descripcion;
};

class Calcetin: public Ropa{
public:
    Calcetin(){};
    Calcetin(int p, int f, string d, string text): Ropa(p,f,d), textura(text) {
    };

    void verCalcetin(){
        cout<<textura<<"$"<<precio<<"-"<<fecha<<"-"<<descripcion<<endl;
    }

    string toString(){
        return descripcion;
    }

private:
    string textura;
};

class Boxers: public Ropa{
public:
    Boxers(){};
    Boxers(int p, int f, string d, string tam): Ropa(p,f,d), tamanho(tam) {
    };

private:
    string tamanho;
};

int main()
{
    //ejemplo básico de Stack
    Stack<int> s;
    s.push(2);
    s.push(3);
    while(s.empty() == false){
        cout <<s.pop();
    }

    //ejemplo básico de Cola
    Cola<int> c;
    c.agregar(2125);
    c.agregar(22);
    c.agregar(3323);
    c.agregar(425);
    cout <<endl<<"mostrando cola"<<endl;
    while(!c.vacia()){
        cout << c.extraer()<<endl;
    }

    //ejemplo básico de Heap
    cout <<endl<<"mostrando Heap"<<endl;
    Heap<string> h;
    h.agregar("Jorge"   , 5);
    h.agregar("Jeffrey" , 3);
    h.agregar("Pablo"   , 1);
    h.agregar("Cristobal" , 2);
    h.agregar("Samuel" , 2);
    h.agregar("Tomas" , 3);
    while(!h.vacia()){
        cout << h.extraer()<<endl;
    }


    Stack<Calcetin> cajaCalcetines;
    Calcetin calcetin1(1000,20201118,"negro con rayas blancas", "suave");
    cajaCalcetines.push(calcetin1);

    Calcetin calcetin2(2000,20201117,"amarillo con puntos","suave");
    cajaCalcetines.push(calcetin2);

    cajaCalcetines.push( Calcetin( 2150, 20190103, "Colegio", "Rugoso") );
    cajaCalcetines.push( Calcetin( 2650, 19860113, "Empresa", "Rugoso") );


    Heap<Calcetin> ordenador;
    cout <<endl<<"Mostrando Stack"<<endl;
    while(cajaCalcetines.empty() == false){
        Calcetin tmp = cajaCalcetines.pop();
        tmp.verCalcetin();
        //agrego al la ordenador
        ordenador.agregar(tmp, tmp.getPrecio());
    }

    cout <<endl<<" Heap por fecha"<<endl;
    while(!ordenador.vacia()){
        Calcetin tmp = ordenador.extraer();
        tmp.verCalcetin();
    }

    return 0;
}