lista.cc

Ir a la documentación de este archivo.

//===========================================================================
//= lista.cc                                                  Julio de 1998 =
//=-------------------------------------------------------------------------=
//= CLASE PARAMETRICA LISTA.                                                =
//= Esta es una implementacion de uso generico de un TAD LISTA simplemente  =
//= encadenada, basada en nodos con apuntadores al siguiente nodo.  La      =
//= LISTA puede indexarse como si se tratase de un arreglo, ya que posee    =
//= una sobrecarga del operador []. Posee metodos que permiten que sea      =
//= usada como una pila.                                                    =
//=-------------------------------------------------------------------------=
//= OJO: Notese que en C++ un "template" es una ayuda para el compilador, y =
//= no puede compilarse por separado para generar codigo objeto.  Este      =
//= modulo debe ser incluido (#include) en los modulos que lo utilicen.     =
//=-------------------------------------------------------------------------=
//= IMPORTANTE: Esta clase NO MANEJA estructuras ni clases, esta disennada  =
//= solamente para tipos de datos basicos y apuntadores.  Para usarla con   =
//= estructuras de datos complejas (i.e. clases), utilize siempre           =
//= apuntadores.                                                            =
//=-------------------------------------------------------------------------=
//= Autor original: Oscar J. Chavarro G.  A.K.A. JEDILINK. Copyright (c),   =
//= 1997 - 2003, oscarchavarro@hotmail.com                                  =
//= AQUYNZA es software libre, y se rige bajo los terminos de la licencia   =
//= LGPL de GNU (http://www.gnu.org). Para mayor informacion respecto a la  =
//= licencia de uso, consulte el archivo ./doc/LICENCIA en la distribucion. =
//===========================================================================

//===========================================================================
//= Encabezados de librerias standard                                       =
//===========================================================================

#ifndef __LISTA__
#define __LISTA__

//#include <stdio.h>

#include "lista.h"

//===========================================================================
//= Clase de soporte NODITO                                                 =
//===========================================================================

template<class T>
NODITO<T>::NODITO(T &data)
{
    info=data;
    sig=0;
}

template<class T>
NODITO<T>::~NODITO()
{
    ;
}

template<class T> void
NODITO<T>::data(T &dato)
{
    dato = info;
}

//===========================================================================
//= CLASE PARAMETRICA LISTA                                                 =
//===========================================================================

//= Servicios basicos ========================================================

template<class T> long int
LISTA<T>::tam(void)
{
    return mi_tam;
}

// OJO: Por alguna extranna razon estas dos tienen que estar definidas
// en el .h para que no salgan como simbolos no definidos!


//template<class T>
//LISTA<T>::LISTA()
//{
//    mi_tam = 0;
//    cab=0;
//}

//template<class T>
//LISTA<T>::~LISTA()
//{
//    elim();
//}

template<class T> T&
LISTA<T>::operator[](int pos)
{
    NODITO<T> *p;
    int i;

    for ( i = 0, p = cab; p && i < pos; i++, p = p->sig ) { ; }
    //if ( p ) {  // Seria bueno, pero degradaria el desempenno de la clase
        return p->info;
    //}
}


template<class T> void
LISTA<T>::elimElem(long int pos)
{
    NODITO<T> *p, *q;

    if ( !cab || pos < 0 || pos >= mi_tam ) {
        return;
    }

    if ( pos == 0 ) {
        cab = cab->sig;
        mi_tam--;
        return;
    }

    int i;

    for ( p = cab, i = 0; i < pos - 1 && p; i++, p = p->sig ) { ; }
    q = p->sig;
    p->sig = q->sig;
    mi_tam--;
    delete q;
}

template<class T> void
LISTA<T>::elim(void)
{
    NODITO<T> *p;
 
    while ( cab ) {
        p=cab;
        cab=cab->sig;
        delete p;
    }
    mi_tam = 0;
    cab = 0;
}

template<class T> void
LISTA<T>::push(T &elm)
{
    NODITO<T> *Nodo;

    Nodo = new NODITO<T>(elm);
    if ( !Nodo ) {
        return;
    }

    Nodo->sig = cab;
    cab=Nodo;
    mi_tam++;
}

template<class T> void
LISTA<T>::anx(T data)
{
    insPosElem(data, mi_tam);
}

template<class T> void
LISTA<T>::insPosElem(T data, long int pos)
{
    NODITO<T> *Nodo, *P, *Q;
    int i;

    Nodo = new NODITO<T>(data);
    // Referencie internamente el nodo

    for ( i = 0, Q = 0, P = cab; P && i < pos; Q = P, P = P->sig, i++ ) { ; }

    if ( !cab || P == cab ) {
        Nodo->sig = cab;
        cab = Nodo;
      }
      else {
        Q->sig = Nodo;
        Nodo->sig = P;
    }

    mi_tam++;
}

//= Servicios de control de la lista por ventana =============================

template<class T> void
LISTA<T>::principio(void)
{
    window = cab;
}

template<class T> void
LISTA<T>::operator ++(void)
{
    if ( window ) window = window->sig;
}

//===========================================================================
//= EOF                                                                     =
//===========================================================================

#endif // __LISTA__

---

Este archivo HTML ha sido generado automáticamente a partir del código fuente AQUYNZA. NO LO EDITE. Para mayor información contacte al autor.