#ifndef LISTASIMPLE_H
#define LISTASIMPLE_H
#include <iostream>

using namespace std;

template<class T>
class Nodo{
public:
    Nodo(T dato, Nodo *s = nullptr){
        this->dato = dato;
        this->siguiente = s;
    }

private:
    T dato;
    Nodo *siguiente;

    template <class>
    friend class ListaSimple;
};

template<class T>
class ListaSimple
{
public:
    ListaSimple();
    bool vacio();
    void insertar(const T &dato);
    void insertar_ultimo(const T &dato);
    void borrar();
    void borrar_final();
private:
    Nodo<T> *raiz;
};

template<class T>
ListaSimple<T>::ListaSimple(){
    raiz = nullptr;
}

template<class T>
bool ListaSimple<T>::vacio(){
    return raiz == nullptr;
}

template<class T>
void ListaSimple<T>::insertar_ultimo(const T &dato){
    Nodo<T> *nuevo = new Nodo<T>(dato);
    if(vacio()){
        raiz = nuevo;
    }
    else{
        Nodo<T> *temp = raiz;
        while (temp->siguiente != nullptr) {
            temp = temp->siguiente;
        }
        temp->siguiente = nuevo;
    }
}

template<class T>
void ListaSimple<T>::insertar(const T &dato){
    Nodo<T> *nuevo = new Nodo<T>(dato);
    if(vacio()){
        raiz= nuevo;
    }
    else{
        nuevo->siguiente = raiz;
        raiz = nuevo;
    }
}

template<class T>
void ListaSimple<T>::borrar(){
    if(!vacio()){
        Nodo<T> *temp = raiz;
        raiz = raiz->siguiente;
        delete temp;
    }
    else {
        throw out_of_range("Imposible eliminar: lista vacia");
    }
}

template<class T>
void ListaSimple<T>::borrar_final(){
    if(!vacio()){
        Nodo<T>*temp=raiz;
        if(temp->siguiente==nullptr){
            borrar();}
        else{
            // 2 o mas elementos.
            while (temp->siguiente->siguiente != nullptr) {
                temp = temp->siguiente;}
            delete temp->siguiente;
            temp->siguiente = nullptr;
        }
    }
    else{
        throw out_of_range("Imposible eliminar: lista vacia");
    }
}


#endif // LISTASIMPLE_H

#ifndef TLISTA_H
#define TLISTA_H

using namespace std;


template <class T>
class Lista{
public:
    Lista(void);
    ~Lista(void);
    bool vacio();
    bool lleno();
    void insertar();
    int cantidad();
    void mostrar();

private:
    T arreglo[3];
    char contador;
};

template <class T>
Lista<T>::Lista(void){
    contador = 0;
}

template <class T>
Lista<T>::~Lista(void){
    delete []arreglo;
}

template<class T>
bool Lista<T>::vacio(){
    return contador==0;
}

template<class T>
bool Lista<T>::lleno(){
    return contador==3;
}

template<class T>
void Lista<T>::insertar(){
    char item;
        if(!lleno()){
            cout<<"Ingrese el valor: ";
            cin>>arreglo[item];
            cout<<"Ingrese el valor: ";
            cin>>item;
            arreglo[contador]=item;}}

template<class T>
int Lista<T>::cantidad(){
    return contador;
}

template<class T>
void Lista<T>::mostrar(){
        for(int i=0;i>3;i++){
            cout<<"Ola";
        cout<<arreglo[i];
              contador++;}
}



#endif // LISTA_H

#include <iostream>
#include "lista.h"

using namespace std;

void menu();

int main()
{
    menu();
    return 0;
}


void menu(){
    Lista<char> List;
    bool bandera=false;
    do{
        char tecla;
            cout << "Menu principal" << endl;
            cout << "-----------" << endl << endl;
            cout << "\t1 .- Ingresar" << endl;
            cout << "\t2 .- Mostrar" << endl;
            cout << "\t3 .- Borrar" << endl;
            cout << "\t4 .- Salir" << endl;
            cout << "elige una opcion: ";

            cin >> tecla;

            switch(tecla)
            {
                case '1':
                    if(List.vacio()){
                        cout<<"Lista vacia"<<endl<<endl;}
                    cout<<"Cantidad: "<<List.cantidad()<<endl;
                    List.insertar();
                    break;

                case '2':

                    List.mostrar();
                    break;

                case '3':
                    break;

                case '4':
                    bandera=true;
                    break;
                }
                }while(bandera!=true);
}

#ifndef LISTA_H
#define LISTA_H

template <typename E>
class Lista{
private:
    void operator=(const Lista&){};
    Lista(const Lista&){};
public:
    Lista(void){};
    virtual ~Lista(void){};
    virtual void Vaciar(void)=0;
    virtual void Insertar(const E&)=0;
    virtual void PonAlFinal(const E&)=0;
    virtual E eliminar(void)=0;
    virtual void IrAlInicio(void)=0;
    virtual void Anterior(void)=0;
    virtual void Siguiente(void)=0;
    virtual int Tamanio(void)const=0;
    virtual int PosicionActual(void)const=0;
    virtual void IrAPosicion(void)=0;
    virtual const Lista &ObtenerElemento(void)const=0;
};

#endif // LISTA_H

#include "lista.h"

template <typename E>
class ListaEstatica: public Lista<E>{
private:
    int TamanioMaximo;
    int TamanioActual;
    int PosActual;
    E *Arreglo;
public:
    ListaEstatica(int){};
    ~ListaEstatica(void){};
    void Vaciar(void);
    void Insertar(const E&);
    void PonAlFinal(const E&);
    E eliminar(void);
    void IrAlInicio(void);
    void Anterior(void);
    void Siguiente(void);
    int Tamanio(void)const;
    int PosicionActual(void)const;
    void IrAPosicion(void);
    const E &ObtenerElemento(void)const;};

//Constructor
template <typename E>
 ListaEstatica<E>::ListaEstatica(int Tamanio){
    TamanioMaximo=Tamanio;
    TamanioActual=PosActual=0;
    Arreglo=new E[Tamanio];}

//Destructor
template <typename E>
ListaEstatica<E>::~ListaEstatica(void){
    delete[]Arreglo;}

template<typename E>
void ListaEstatica<E>::Vaciar(void){
    delete[]Arreglo;
    TamanioActual=PosActual=0;
    Arreglo=new E[TamanioMaximo];}

template<typename E>
void ListaEstatica<E>::Insertar(const E& A){
    for(int i=TamanioMaximo;i>PosActual;i--){
        Arreglo[i]=Arreglo[i-1];}
        Arreglo[PosActual]=A;
        TamanioMaximo++;}

template<typename E>
void ListaEstatica<E>::PonAlFinal(const E& A){
    Arreglo[TamanioActual++]=A;}

template<typename E>
E ListaEstatica<E>::Eliminar(void){
    E A=Arreglo[PosActual];
    for(int i=PosActual;i<TamanioActual;i++){
        Arreglo[i]=Arreglo[i+1];}
    TamanioActual--;
    return A;
}

template<typename E>
void ListaEstatica<E>::IrAlInicio(void){
    for(int i=PosActual;i<TamanioActual;i--){
        Arreglo[PosActual];}}

//clases/complejo.h
/*Interfaz de la clase complejo*/

#ifndef complejo_H
#define complejo_H

class Complejo{
private:
    float real;
    float imaginario;
public:
    Complejo(float _real,float _imaginario);//Constructor.
    float obtenerReal(void);
    float obtenerImaginario(void);
    void suma(float &real,float &imaginario);
    void resta(float &minuendo,float &sustraendo);
    void multiplicacion(float &multiplicando,float &multiplicador);
    void division(float &dividendo,float &divisor);};
#endif // complejo_H

//clases/complejo.cpp
/*
**Implementación de la clase complejo.*/

#include <iostream>
#include "complejo.h"
using std::cout;
using std::endl;

//Constructor.
Complejo::Complejo(float _real,float _imaginario){
    this->real=_real;
    this->imaginario=_imaginario;}

float Complejo::obtenerReal(void){
    cout<<"Numero real: "<<real<<endl;
    cout<<endl;
    return real;}

float Complejo::obtenerImaginario(void){
    cout<<"Numero imaginario: "<<imaginario<<endl;
    cout<<endl;
    return imaginario;}

void Complejo::suma(float &sum1,float &sum2){
    cout<<"La suma es: "<<real+imaginario<<endl;}

void Complejo::resta(float &minuendo,float &sustraendo){
    cout<<"La resta es: "<<real-imaginario<<endl;}

void Complejo::multiplicacion(float &multiplicando,float &multiplicador){
    cout<<"La multiplicacion es: "<<real*imaginario<<endl;}

void Complejo::division(float &dividendo,float &divisor){
    cout<<"La division es: "<<real/imaginario<<endl;}

int main(void){
    float x,y;
    Complejo h= Complejo(5,1);
    h.obtenerReal();
    h.obtenerImaginario();
    h.suma(x,y);
    h.resta(x,y);
    h.multiplicacion(x,y);
    h.division(x,y);
    return 0;
}

//clases/complejo.h
/*Interfaz de la clase complejo*/

#ifndef complejo_H
#define complejo_H

class Complejo{
private:
    float real;
    float imaginario;
public:
    complejo(float real,float imaginario);
    float obtenerReal(void);
    float obtenerImaginario(void);
    void suma(float sum1,float sum2);
    void resta(float minuendo,float sustraendo);
    void multiplicacion(float multiplicando,float multiplicador);
    void division(float dividendo,float divisor);};
#endif // complejo_H

//clases/complejo.cpp
/*
**Implementación de la clase complejo.*/

#include <iostream>
#include "complejo.h"
using std::cout;
using std::endl;

Complejo::complejo(float real,float imaginario){
    this->real=real;
    this->imaginario=imaginario;}
float Complejo::obtenerReal(void){
    return 1;}
float Complejo::obtenerImaginario(void){
    return imaginario;}
void Complejo::suma(float sum1,float sum2){
    real=sum1;
    imaginario=sum2;;
    cout<<"La suma es: "<<sum1+sum2<<endl;}
void Complejo::resta(float minuendo,float sustraendo){
    real=minuendo;
    imaginario=sustraendo;
    minuendo-sustraendo;}
void Complejo::multiplicacion(float multiplicando,float multiplicador){
    real=multiplicando;
    imaginario=multiplicador;
    multiplicador*multiplicador;}
void Complejo::division(float dividendo,float divisor){
    real=dividendo;
    imaginario=divisor;
    dividendo/divisor;}

int main(void){
    Complejo h;
    h.obtenerReal();
    cout<<h.obtenerReal()<<endl;
    h.obtenerImaginario();
    return 0;
}

#include <stdio.h>

struct Hora{
    int hora;
    int minuto;
    int segundo;};

struct Hora inicializa(void);
void estableceHora(struct Hora *var, int hor, int min,int seg);
void imprimeMilitar(struct Hora *var);
void imprimeEstandar(struct Hora *var);

int main(void){
    struct Hora h=inicializa();
    imprimeMilitar(&h);
    imprimeEstandar(&h);
    estableceHora(&h,13,27,6);
    imprimeEstandar(&h);
    imprimeEstandar(&h);
    estableceHora(&h,66,66,66);
    imprimeMilitar(&h);
    imprimeEstandar(&h);
    return 0;}

struct Hora inicializa(void){
struct Hora horacero={0,0,0};
return horacero;}

void estableceHora(struct Hora *var, int hor,int min,int seg){
    var->hora=(hor>=0&&hor<24)?hor:0;
    var->hora=(min>=0&&min<60)?hor:0;
    var->hora=(seg>=0&&seg<60)?hor:0;}

void imprimeMilitar(struct Hora *var){
    printf("%s%i:%s%i\n",(*var).hora<10?"0":"",(*var).hora,(*var).minuto<10?"0":"",(*var).minuto);}

void imprimeEstandar(struct Hora *var){
    printf("%i:%s%i:%s%i\n",((*var).hora==0||(*var).hora==12)?12:(*var).hora%12,(*var).minuto<10?"0":"",(*var).segundo<10?"0":"",(*var).segundo,(*var).hora<12?"AM":"PM");}