20201120 Clase Ejemplos de Heap, Colas, Stack, Polimorfismo, Clases Compuestas, administrar Vectores de clases

#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(){
        precio = 0;
        fecha = 0;
        descripcion = "";
    };

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

    void setFecha(int valor){
        this->fecha = valor;
    }

    void setPrecio(int valor){
        this->precio = valor;
    }

    void setDescripcion(string valor){
        this->descripcion = valor;
    }

    int getFecha(){
        return fecha;
    }

    int getPrecio(){
        return precio;
    }

    string getDescripcion(){
        return this->descripcion;
    }

    virtual void ver() {
        cout <<"nada"<<endl;
    }

    //funcion implementada sólo en el hijo tipo boxer
    virtual string getTamanho(){
        return "";
    };

protected:
    int precio;
    int fecha;
    string descripcion;
};

class Calcetin: public Ropa{
public:
    Calcetin(){
        textura = "";
    };

    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 + " - " + to_string(precio); //concatenar
    }
    void ver(){
        cout <<"calcetin " <<fecha <<" $"<<precio <<" D:"<<descripcion <<endl;
    }

private:
    string textura;
};

class Polera: public Ropa{
public:
    Polera(){
       tamanho = "";
    };

    Polera(int p, int f, string d, string tam): Ropa(p,f,d), tamanho(tam) {
    };

    void ver(){
        cout <<"Polera " <<fecha <<" $"<<precio <<" D:"<<descripcion <<endl;
    }

private:
    string tamanho;
};

class Boxer: public Ropa{
public:
    Boxer(){
        tamanho = "";
    };

    Boxer(int p, int f, string d, string tam): Ropa(p,f,d), tamanho(tam) {
    };

    void ver(){
        cout <<"Boxer " <<fecha <<" $"<<precio <<endl;
    }

    void setTamanho(string valor){
        this->tamanho = valor;
    }
    string getTamanho(){
        return tamanho;
    }
    void largo(){
        cout <<"calculando largo boxer: "<<tamanho<<endl;
    }

private:
    string tamanho;
};

class Persona {
public:
    Persona(){
        nombre = "";
    }
    Persona(string n){
        nombre = n;
    }
    void setPersona(string n){
        nombre = n;
    }
    string getPersona(){
        return nombre;
    }
private:
    string nombre;
};

class Compra {
public:
    Compra(){
        indiceCalcetines = 0;
    };
    void setAgregarCompra(int posicion, Polera ropaAAgregar){
        if(posicion < MAX_POLERAS && posicion > 0)
            carrito[posicion] = ropaAAgregar;
        else
            cout <<"[error] fuera de indice"<<endl;
    }
    Polera getCompra(int posicion) {
        if(posicion < MAX_POLERAS && posicion > 0)
            return carrito[posicion];
        else {
            cout <<"[error] fuera de indice"<<endl;
            return Polera();
        }
    }

    void setPersona(string n){
        persona.setPersona(n);
    }
    string getPersona(){
        return persona.getPersona();
    }

    void agregarBoxer(Boxer b){
        carritoBoxer.push(b);
    }

    Boxer quitarBoxer(){
        if(!carritoBoxer.empty())
            return carritoBoxer.pop();
        else {
            cout << "[error] fuera de indice"<<endl;
            return Boxer();
        }
    }


    void setAgregarCalcetin(Calcetin nuevoCalcetin){
        if(indiceCalcetines < MAX_CALCETINES && indiceCalcetines >= 0)
            carritoCalcetines[indiceCalcetines++] = nuevoCalcetin;
        else
            cout <<"error";
    }

    Calcetin quitarCalcetin() {
        if(indiceCalcetines >= 0) {
            return carritoCalcetines[indiceCalcetines--];
            if(indiceCalcetines < 0)
                indiceCalcetines = 0;
        }
        else {
            cout <<"fuera de index calcetin";
            return Calcetin();
        }
    }

private:
    Persona persona; //composición de clase

    static const int MAX_POLERAS = 10;
    Polera carrito[MAX_POLERAS]; //composición de clase utilizando un vector
    Stack<Boxer> carritoBoxer;

    static const int MAX_CALCETINES = 100;
    int indiceCalcetines;
    Calcetin carritoCalcetines[MAX_CALCETINES]; //composición de clase utilizando un vector

};

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; //creamos el stack
    Calcetin calcetin1(1000,20201118,"negro con rayas blancas", "suave");
    cajaCalcetines.push(calcetin1);

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

    cout <<calcetin2.getFecha();
    cout <<calcetin2.getPrecio();
    cout <<calcetin2.toString();
    calcetin2.verCalcetin();

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

    Cola<Polera> cajaPoleras;
    cajaPoleras.agregar( Polera (1000, 20201010, "Polera de Mr Robot", "xl"));
    cajaPoleras.agregar( Polera (2200, 20201001, "Polera de Pacman", "l"));

    Heap<Boxer> cajaBoxer;
    cajaBoxer.agregar( Boxer(2500, 20190101, "Boxer negro", "s") ,1);
    cajaBoxer.agregar( Boxer(2500, 20190101, "Boxer blanco", "l") ,1);

    //como realizamos un vector de Boxer
    Boxer vB[10];
    vB[0] = Boxer(2500, 20190101, "Boxer negro", "s");
    vB[1] = Boxer(2500, 20190101, "Boxer negro", "s");
    vB[3] = Boxer(2500, 20190101, "Boxer negro", "s");


    Heap<Calcetin> ordenador;

    cout <<endl<<"Mostrando Stack"<<endl;

    while(cajaCalcetines.empty() == false){
        Calcetin auxCalcetin = cajaCalcetines.pop();
        auxCalcetin.verCalcetin();
        cout <<auxCalcetin.toString();

        ordenador.agregar( auxCalcetin, auxCalcetin.getPrecio() );
    }

    cout <<endl<<" Heap por fecha"<<endl;

    while(!ordenador.vacia()){
        Calcetin auxCalcetin = ordenador.extraer();
        auxCalcetin.verCalcetin();
        cajaCalcetines.push(auxCalcetin);
    }

    //un stack de ropa en que utilizaremos polimorfismo
    Stack<Ropa *> bodega;

    //agregamos calcetines
    bodega.push( new Calcetin( 2150, 20190103, "Colegio", "Rugoso"));

    while(!cajaCalcetines.empty()) {
        Calcetin aux = cajaCalcetines.pop();
        bodega.push( new Calcetin(aux) );
    }

    //agregamos poleras
    while(!cajaPoleras.vacia()) {
        Polera polera = cajaPoleras.extraer();
        bodega.push( new Polera(polera) ) ;
    }

    //agregamos boxer
    while(!cajaBoxer.vacia()) {
        bodega.push( new Boxer(cajaBoxer.extraer()));
    }

    Cola<Boxer> nuevaCaja;

    cout <<endl<<"mostrando bodega"<<endl;
    while(!bodega.empty()) {
        Ropa *ropa = bodega.pop();
        ropa->ver();
        cout <<"Tipo: ["<<typeid(*ropa).name()<<"]"<<endl;
        string tipo = typeid(*ropa).name();

        if(tipo == "5Boxer"){
            cout <<"este es un Boxer tamanho: "<<ropa->getTamanho()<<endl;
            //para traspasar el objeto polimorfico nuevamente a su origen
            //debemos utilizar los getters y setters.
            //En este caso se el método getTamanho sólo esta implementado en la clase Boxer
            Boxer boxerNuevo;
            boxerNuevo.setDescripcion(ropa->getDescripcion());
            boxerNuevo.setFecha(ropa->getFecha());
            boxerNuevo.setPrecio(ropa->getPrecio());
            boxerNuevo.setTamanho(ropa->getTamanho());
            nuevaCaja.agregar(boxerNuevo);
        }
    }

    /***********TERCERA PARTE DE LA CLASE Pregunta sobre implementación de composición de clases ****/

    cout <<endl<<"implementación de composición de clases"<<endl;
    Polera ropa1;
    Polera ropa2;

    Compra compraDelMes;
    compraDelMes.setPersona("Juan Perez");

    compraDelMes.setAgregarCompra(1, ropa1);
    compraDelMes.setAgregarCompra(2, ropa2);

    Polera ropaComprada = compraDelMes.getCompra(1);
    Polera ropaComprada2 = compraDelMes.getCompra(2);
    Polera ropaComprada3 = compraDelMes.getCompra(3);

    compraDelMes.getCompra(1).ver();

    compraDelMes.agregarBoxer( Boxer(2500, 20190101, "Boxer negro", "s"));
    compraDelMes.quitarBoxer().ver();
    compraDelMes.quitarBoxer().ver();
    compraDelMes.quitarBoxer().ver();

    compraDelMes.setAgregarCalcetin(Calcetin(1000,20201118,"negro con rayas blancas", "suave"));
    Calcetin calcetinVendido = compraDelMes.quitarCalcetin();
    calcetinVendido.ver();

    compraDelMes.quitarCalcetin();


    return 0;
}