#ifndef ARREGLO_H
#define ARREGLO_H

template < typename Tipo >
class Arreglo
{
    public:
        Arreglo();
        ~Arreglo();

        // Permite agregar elementos
        void agregarInicio(const Tipo &);
        /*void agregarFin(const Tipo &);

        // Permite eliminar elementos del arreglo
        void eliminar_incio();
        void eliminar_fin();*/
        void eliminar(int);

        // Devuelve una referencia al elemento del subíndice dado
        Tipo & operator [] (int);

        // Indica si está vacío el arreglo
        bool estaVacio();

    private:
        Tipo * arreglo;     // Sobre éste se crea el arreglo
        unsigned int tamanio;   // Tamaño del arreglo
        unsigned int rango;     // La cantidad de elementos usados en el arrglo
};

#endif // ARREGLO_H

template < typename Tipo >
Arreglo<Tipo>::Arreglo()
{
   arreglo = 0;
   tamanio = 0;
   rango = 0;
}

template < typename Tipo >
Arreglo<Tipo>::~Arreglo()
{
    delete [] arreglo;
    tamanio = 0;
    rango = 0;
}

 // Añade elementos a por el inicio del arreglo
 template < typename Tipo >
 void Arreglo<Tipo>::agregarInicio(const Tipo &nElemento)
 {
    // ¿El arreglo no está vacío?
    if( !estaVacio() )
    {
        // Crea un arreglo temporal donde se guardarán los nuevos datos
        Tipo * arregloTemp = new Tipo[tamanio + 1];

        // Agrega el primer elemento al nuevo arreglo
        arregloTemp[0] = nElemento;

        // Añade el resto de los elementos al arreglo
        for(int i = 1; i < tamanio + 1; i++)
        {
            arregloTemp[i] = arreglo[i - 1];
        }

        // Elimina el arreglo antiguo
        delete [] arreglo;

        // Asigna el nuevo arreglo
        arreglo = arregloTemp;

        // Aumenta el número de elementos
        tamanio += 1;
        rango += 1;
    }
    else
    {
        // Crea un arreglo para un elemento
        arreglo = new Tipo[1];

        // Asigna el elemento dado
        arreglo[0] = nElemento;

        // Incrementa el tamaño del arreglo
        tamanio++;

        // Incrementa el tamaño del rango
        rango++;
    }
}

template < typename Tipo >
// Elimina el elemento del subíndice indicado
void Arreglo<Tipo>::eliminar(int subindice)
{
    // ¿El arreglo tiene un elemento?
    if( rango == 1 )
    {
        // Elimina el arreglo
        delete arreglo;
        arreglo = 0;

        // El rango es 0
        rango = 0;

        // El tamaño es 0
        tamanio = 0;
    }
    else if( !estaVacio() )
    {
        // Crea un arreglo temporal donde se guardarán los nuevos datos
        Tipo * arregloTemp = new Tipo[tamanio - 1];

        // Copia los elementos restantes del arreglo
        for( int i = 0; i < tamanio - 1; i++)
        {
            // ¿Es el subindice indicado?
            if( i != subindice )
            {
               // Asigna la cantidad
               arregloTemp[i] = arreglo[i];
            }
        }

        // Elimina el arreglo
        delete arreglo;

        // Asigna el arreglo
        arreglo = arregloTemp;
    }
}

template < typename Tipo >
Tipo& Arreglo<Tipo>::operator[] (int subindice )
{
    if( subindice < rango )
    {
        return arreglo[subindice];
    }
}

template < typename Tipo >
// Indica si está vacío el arreglo
bool Arreglo<Tipo>::estaVacio()
{
    return arreglo == 0;
}