PLANTILLAS

Plantillas en C++
Las plantillas nos permiten especificar, con un solo segmento de cdigo, un rango completo de funciones relacionadas (sobrecargadas), llamadas funciones de plantilla, o un rango completo de clases relacionadas, llamadas clases de plantilla. Podramos escribir una sola plantilla de funcin para una funcin de ordenamiento de arreglos luego !acer "ue #$$ generara autom%ticamente funciones de plantilla separadas "ue ordenaran un arreglo de int, un arreglo de float, un arreglo de string, etc. Podramos escribir una sola plantilla de clase de pila luego !acer "ue #$$ generara autom%ticamente clases de plantillas separadas, tales como una clase de pila de int, una clase de pila de float, una clase de pila de string, etc. &a "ue obser'ar la diferencia entre las plantillas de funcin las funciones de plantilla( las plantillas de funcin las plantillas de clase son como plantillas con las cuales tra)amos formas, las funciones de plantilla las clases de plantilla son como los tra)os separados, "ue tienen la misma forma pero pueden tra)arse en colores diferentes, por e*emplo. Plantillas de funcin Las funciones sobrecargadas se utili)an normalmente para reali)ar operaciones similares sobre diferentes tipos de datos. Si las operaciones son id+nticas para cada tipo, esto puede reali)arse en forma m%s compacta con'eniente mediante el uso de plantillas de funcin. ,as%ndose en los tipos de argumento "ue se proporcionan en las llamadas a esa funcin, el compilador genera autom%ticamente funciones de cdigo ob*eto separadas para mane*ar adecuadamente cada tipo de llamada. -n # esta tarea se puede reali)ar mediante macros creadas con la directi'a de preprocesador #define. Sin embargo las macros presentan la posibilidad de serios efectos secundarios no permiten "ue el compilador realice re'isin de tipo. Las plantillas de funcin proporcionan una solucin compacta similar a la de las macros, pero permiten una re'isin de tipo completa. Todas las definiciones de plantillas de funcin comien)an con la palabra cla'e t+mplate, seguida de una lista de par%metros formales para dic!a plantilla encerrados entre par+ntesis angulares (. /), cada par%metro formal "ue representa un tipo debe estar precedido por la palabra cla'e class, como en(

template <class T> template <class Element Type> template <class BorderType, class FillType>

Los par%metros formales de una definicin de plantilla se utili)an (como sucedera con los argumentos de tipos integrados o de tipos definidos por el usuario) para especificar los tipos de argumentos de la funcin, para especificar el tipo de de'olucin de la funcin para declarar 'ariables en el interior de la funcin. Para definir una plantillas de clase, se puede usar el siguiente formato(

template <class T> class Nombre { . . .uso del parmetro T en funciones o datos miembro.. }

Primer programa -l siguiente programa !ace uso de plantillas para determinar el mnimo m%0imo 'alor de un arreglo de elementos dado. La primera funcin recibe tiene como par%metros un puntero al tipo de elemento dado el n1mero de elementos retorna el menor de los elementos "ue se encuentran en el arreglo. La segunda funcin recibe los mismos par%metros retorna el ma or de los elementos presentes en el arreglo. 2inalmente en la funcin main, se !ace una prueba de estas funciones, con arreglos de enteros flotantes.

#include <iostream. > #include <conio. > template <class T> T minimo !T " #rray, int num$elemen% { T min& #rray '() * for !int i&+* i< num$elemen* i,,% if! #rray' i ) < min% min & #rray ' i )* } * return min*

template <class T> T ma-imo !T " #rray, int num$elemen% { T ma-& #rray '()* for !int i&+* i< num$elemen* i,,% if! #rray' i ) > ma-% ma- & #rray ' i )* }* return ma-*

.oid main!.oid% { int #rray/nt '0) & { 1, 2, 3}* float #rrayFloat '0) & { +1.+, 2.4, 5.3 }* int i* cout<<6#rre7lo de enteros8 6* for !i&(* i<0* i,,% cout << #rray/nt' i ) << 6 6* cout << endl << 6Numero minimo8 6 << minimo !#rray/nt, 0% << endl <<6Numero ma-imo8 6 << ma-imo !#rray/nt, 0% << endl << endl* cout << 6#rre7lo de flotantes8 6* for !i&(* i<0* i,,% cout << #rrayFloat' i ) << 6 6* cout << endl <<6Numero minimo8 6 << minimo !#rrayFloat, 0% << en dl 7etc !%* } <<6Numero ma-imo8 6 << ma-imo !#rrayFloat, 0%*

Segundo programa

-n este programa se !ace uso de plantillas, para elaborar una funcin "ue permita ordenar los elementos de un arreglo. -sta funcin recibe tiene como par%metros, un puntero al tipo de elemento dado, dos enteros "ue indican los ndices del primero 1ltimo elemento. A"u se !ace uso del algoritmo OrdenarShell para lle'ar a cabo la tarea. -n la funcin principal se prueba esta plantilla con arreglos de enteros flotantes.

#include <iostream. > #include <conio. > template <class T> .oid 9rdenar ! T " a, int st, int fn% { int i, : , ;* T item$a$ordenar* ; & + * do {

;& 0 " ; , +* } < ile !; < fn = st , +% *

do { ; >& 0 * for !i& st,;* i<&fn* i,,% { item$a$ordenar & a ' i ) * : & i * < ile !item$a$ordenar < a ' :=;)% { a ' :) &a ' :=;) * : =&;* if!: < st,;% brea;* } a ':)&item$a$ordenar* } } < ile!; > +%*

.oid main!.oid% { int #rraylnt'0) & { 1, 0, + } * float #rrayFloat'0) & {15.(, 0.(, ?5.1 } * int i * cout << 6Enteros8 6 << endl << 6#rre7lo ori7inal8 6* for !i&(* i<0* i,,% cout << #rraylnt' i ) << 6 6* 9rdenar!#rraylnt, (, 1%* cout << endl << 6@ue7o de ordenar8 6* for !i&(* i<0* i,,% cout << #rraylnt' i ) << 6 6* cout << endl << endl << 6Flotantes8 6 << endl << 6#rre7lo ori7inal8 6*

cout << #rrayFloat' i ) << 6 6* 9rdenar!#rrayFloat, (, 1%* cout << endl << 6@ue7o de ordenar8 6* for !i&(* i<0* i,,% cout << #rrayFloat' i ) << 6 6*

Tercer programa 7etc !% * -n este programa se implementa, mediante el uso de plantillas la clase Nue'aPila, "ue consiste en una Pila, en la "ue se pueden lle'ar a cabo las operaciones como insertar eliminar datos de la misma, mostrar en pantalla los datos de la pila. -sta es una pila est%tica, con un n1mero predefinido de 34 elementos. -n al funcin principal, se usa una pila de enteros, flotantes caracteres para poder lle'ar a cabo una prueba de la plantilla creada.
}

#include <iostream. > #include <conio. > enum estado$pila { 9A, @@EN#, B#C/# }* template <class T> class Nue.aDila { int tamanyo* T "tabla* int cima* estado$pila estado* public8 Nue.aDila!int &+(%* ENue.aDila!% { delete ') tabla* } .oid meter !T%* T sacar !%* .oid .isualiFar !%* int num$elementos !%* int leer$tamanyo !% { return tamanyo* }

template <class T> Nue.aDila <T> 88 Nue.aDila !int tam% { tamanyo&tam* tabla& ne< T 'tamanyo) * cima&(* estado&B#C/#* } template <class T> .oid Nue.aDila <T> 88 meter !T elemento% { if! estadoG&@@EN#% tabla 'cima,,)&elemento* else cout << 6""" Dila llena """6* if!cima>&tamanyo% estado&@@EN#* else estado&9A*

template <class T> T Nue.aDila <T> 88 sacar !% { T elemento&(* if!estadoG&B#C/#% elemento&tabla'==cima)* else cout<<6""" Dila .acHa """6* if!cima<&(% estado&B#C/#* else estado&9A* return elemento* }

.oid Nue.aDila <T> 88 .isualiFar !% { for !int i&cima=+* i >&(* i==% cout << tabla' i ) <<6 6* } template <class T> int Nue.aDila <T> 88 num$elementos !% { Cuarto ejemplo return cima* }

5ediante el uso de plantillas cree una clase #ola, en la "ue se puedan lle'ar a cabo operaciones .oid main!% como( encolar, decolar e imprimir los datos miembro. 6ealice una funcin { controladora para probar el uso de esta clase. cout Nodo#ola, << 6Drobando pila amiga de enteros6* La clase tiene como a la clase #ola. Se presenta adem%s una funcin para las opciones del usuario, "ue se encarga de Nue.aDila <int> s+ !5%* reali)ar las llamadas a las funciones de las clases. -sta s+.meter!5%* funcin es llamada desde main. s+.meter!+(%* -n la funcin main se !a usado como e*emplo una cola de enteros, aun"ue tambi+n se s+.meter!+5%* pudo !aber usado otro tipo de datos como( char, double, otros.
cout << endl << 6Numero de elementos8 6 << s+.num$elementos!% << endl <<6Dila8 6* s+..isualiFar!%* cout << endl << 6Iacando elementos 8 6 << s+.sacar!% <<6 6 << s+.sacar!% << 6 6 << s+.sacar!% << endl * s+.sacar!%* cout << endl << endl << 6Drobando pila de flotantes6* Nue.aDila <float> s1 !5%* s1.meter!4.5%* s1.meter!+(.1%* s1.meter!+5.0%* cout << endl << 6Numero de elementos8 6 << s1.num$elementos!% << endl <<6Dila8 6* s1..isualiFar!%* cout << endl << 6Iacando elementos 8 6 << s1.sacar!% << 6 6 << s1.sacar!% << 6 6 << s1.sacar!% << en dl* s1.sacar !%* cout << endl << endl << 6Drobando pila de caracteres6* Nue.aDila <c ar> s0 !5%* s0.meter!JmJ%* s0.meter!JpJ%* s0.meter!JsJ%* cout << endl << 6Numero de elementos8 6 << s0.num$elementos!% << endl <<6Dila8 6* s0..isualiFar!%* cout << endl << 6Iacando elementos 8 6 << s0.sacar !% << 6 6 << s0.sacar!% << 6 6 << s0.sacar!% << en dl* s0.sacar!%* 7etc !%*

#include <iostream. > #include <conio. > #include <assert. > template <class T/D9N9K9> class Cola* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >> definicion clase NodoCola >>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> template <class T/D9N9K9> class NodoCola { T/D9N9K9 dato* NodoCola <T/D9N9K9> " si7* public8 NodoCola !const T/D9N9K9 L%* T/D9N9K9 7etKato!% const* friend class Cola <T/D9N9K9>* }* >> constructor template <class T/D9N9K9> NodoCola <T/D9N9K9> 88 NodoCola !const T/D9N9K9 L info% 8 dato!info%, si7 !(% { } >> de.uel.e una copia del dato Mue esta en el nodo template <class T/D9N9K9> T/D9N9K9 NodoCola <T/D9N9K9> 88 7etKato!% const { return dato* } >> definicion enumeracion >> enum bool { false, true }* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >> definicion clase Cola >>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> template <class T/D9N9K9> class Cola { NodoCola <T/D9N9K9> " primero* >> puntero al primer nodo NodoCola <T/D9N9K9> " ultimo* >> puntero al ultimo nodo public8 Cola !%* >> constructor ECola!%* >> destructor .oid encolar !const T/D9N9K9 L%* >> permite insertar nodo bool decolar !T/D9N9K9 L%* >> permite eliminar nodo bool estaBacia!% const* >> .erifica si la cola esta .a cia .oid imprimir!% const* >> imprime datos de la cola >> funciNn de utileria para asi7nar un nue.o nodo NodoCola <T/D9N9K9> " 7etNue.oNodo !const T/D9N9K9 L%*

>> dato >> puntero si7uiente nodo >> constructor >> de.uel.e dato del nodo >> ace Mue Cola sea friend

}*

>> constructor predeterminado template <class T/D9N9K9> Cola <T/D9N9K9> 88 Cola !%8 primero!(%, ultimo!(% { } >> destructor

Cola <T/D9N9K9> 88 ECola !% { if! GestaBacia!% % { >> in7resa si la cola no esta .acia cout<<6Eliminando nodos ...6 << endl* NodoCola <T/D9N9K9> " actual & primero, "temporal* < ile !actual G& (% { >> borra los nodos restantes $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ temporal & actual* $$$$$$$$$$ cout<< temporal=>dato << endl* } Plantillas } } actual & actual=>si7* delete temporal* an sido eliminados6 << endl << endl*

[editar] Introduccin
>> inserta un nodo

cout << 6Todos los nodos

Con el objeto de explicar la razn de la necesidad de la existencia de las plantillas debemos template <class T/D9N9K9> .oid Cola sobre <T/D9N9K9> 88 encolar !const T/D9N9K9 L .alor% reflexionar tres paradgmas de programacin anteriores, estas{son: programacin <T/D9N9K9> " nue.o & 7etNue.oNodo !.alor%* orientada al objeto clsicaNodoCola o procedimental, programacin estructurada y programacin POO if ! estaBacia!% % >> si la cola esta .acia Programacin
primero&ultimo&nue.o*

clsica
>> si la cola no esta .acia

!n el como clsica existe una clara diferenciacin entre los datos entre los datos y el conjunto de algoritmos para manejarlos "os datos son tipos muy simples y generalmente los algoritmos se agrupan en } funciones orientadas de forma muy especfica a los datos #ue deben manejar Por ejemplo, >> se elimina si escribe un unanodo funcin $ sort % para ordenar en forma ascendente o descendente los template <class T/D9N9K9> n&meros contenidos en un arreglo de n&meros enteros, dic'a funcin puede aplicarse a bool Cola <T/D9N9K9> 88 decolar !T/D9N9K9 L .alor% { cual#uier arreglo de enteros tipo (&n asi, la programacin if! estaBacia!% % ms no a arreglos >> de la otro cola esta .acia clsicareturn pro)ee false* el soporte necesario para la reutilizacin de cdigo ya #ue el cdigo de la >> eliminacion no satisfactoria funcin se escribe solamente una )ez y su reutilizacin se da por medio de un mecanismo NodoCola <T/D9N9K9> "temporal & primero* conocido como llamada de funcin Programacin primero&ultimo&(*
if!primero&&ultimo%

else { ultimo=>si7&nue.o* tipo de programacin conocida ultimo&nue.o* y su manipulacin, es decir, }

estructurada

!n la else medida en #ue los datos #ue 'aba de manipular se iban 'aciendo cada )ez ms primero&temporal=>si7* complejos se busco la forma de agruparlos de alguna manera bajo un mismo nombre, es asi como .alor&temporal=>dato* surjen las estructuras de datos *uc'os se se refieren la programacin >> autores dato Mue esta a eliminando estructura como a la suma de funciones y+o procedimientos ms estructura de datos delete temporal*
return true* } Programacin >> eliminacion satisfactoria

Orientada

al

Objeto

"a Programacin Orientada al Objeto $ POO % introduce nue)as facilidades y se extiende el template <class T/D9N9K9> concepto de dato, permitiendo #ue existan !% tipos ms complejos, es decir, si la programacin bool Cola <T/D9N9K9> 88 estaBacia const { if !primero&&(% return true* estructurada establece las bases para la manipulacin de funciones y datos estructurados, la return false* POO establece las bases para manipular datos y funciones como un solo objeto !sta nue)a } 'abilidad )iene acompa,ada por ciertas mejoras adicionales: la posibilidad de ocultacin de determinados detalles internos para el usuario y la capacidad de 'erencia >> imprime el contenido de irrele)antes la cola template <class T/D9N9K9> simple o m&ltiple
.oid Cola <T/D9N9K9> 88 imprimir!% const { if ! estaBacia!% % { Notas: !l ocultamiento de cdigo asi como la 'erencia estan presentes $ en una forma cout<<6@a lista esta .acia6 << endl << endl* simplereturn* % en la programacin estructurada, y los mismos ad#uieren muc'a ms rele)ancia en la POO } Por ejemplo, en la programacin estructurada si usted escribe una librera de NodoCola <T/D9N9K9> "actual & primero* cout<<6@a cola es8 6* < ile !actualG&(% { cout<< actual=>dato <<6 6*

>> .erifica si la cola esta .acia

} } cout << endl << endl*

>> funcion de utileria8 de.uel.e un apuntador a un nodo recientemente as i7nado funciones, al usuario de dic'a librera solamente le informar de la existencia de tal o cual template <class T/D9N9K9> funcin, asi como el objeti)o y la forma correcta para comunicarse con estas, pero no NodoCola <T/D9N9K9> " Cola <T/D9N9K9> 88 7etNue.oNodo !const T/D9N9K9 L es necesario .alor% {#ue se le expli#ue el funcionamiento interno de las mismas Por otro lado, es bien NodoCola <T/D9N9K9> " nue.o & yne< NodoCola !.alor%* conocido #ue lenguajes tales como Pascal C, por ejemplo,<T/D9N9K9> dan el soporte para la creacin assert!nue.oG&(%* de datos estructurados $ -ecord en Pascal, y struct en C %, y #ue dic'as estructuras pueden return nue.o* contener a otras estructuras pre)iamente definidas .e tal manera )emos como a los }

usuarios de las funciones se les oculta el cdigo de las mismas, y #ue una estructura #ue >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> contiene a otra 'ereda los miembros de la estructura contenida
>>>>>

Programacin >> funcion Mue prueba una cola

template <class T>

genrica

"a programacin gen/rica est muc'o ms centrada .oid probarCola ! Cola <T> L 9b:etoCola% {en los algoritmos #ue en los datos, y su postulado fundamental puede sintetizarse en una palabra: generalizacin 0ignifica #ue, en T .alor* la medida de lo posible, los algoritmos deben ser parametrizados al mximo y expresados int opcion* de la forma ms independiente posible de detalles concretos, permitiendo as #ue puedan ser)ir para mayor )ariedad posible de tipos y estructuras de datos for la !**%{
cout<<endl<<6!+% /nsertar, !1% Eliminar, !0% /mprimir, !?% Ia lir6<<endl* Con el objeti)o de mostrar de una manera practica las diferencias entre los tres tipos de 6* programacincout<<6Ieleccion8 mencionados arriba tomaremos como base el modelo de una )ieja estructura cin>>opcion*

de datos amiga de los programadores, me refiero a un array, tambien conocida por muc'os como arreglo,s<itc tabla o! lista Para %{ no entrar en polemicas de estndarizacin de nombrado en opcion case +8 este captulo diremos #ue la estructura modelo con la #ue trabajaremos es un )ector cout<<6/n7rese dato8 6* $ arreglo unidimensional % Pues bien, dado un de crear un cierto n&mero de funciones #ue sean las encargadas de la manipulacin de los datos dentro del )ector Para case 18 en las funciones: comenzar, podemos pensar 1 mostrar, para desplegar o imprimir los elementos del )ector ordenar los elementos del )ector
if!9b:etoCola.decolar!.alor%% cout<<6Kato 6 << .alor <<6 eliminado6 << endl << endl* cin>> .alor* 9b:etoCola.encolar!.alor%* )ector cual#uiera se presenta la necesidad brea;*

2 << ordenar, endl endl*para 3 4 5

}

else cout<<6No puede eliminar 8 la cola esta .acia6 <<

brea;* la presencia o ausencia de un determinado elemento dentro buscar, para determinar del )ector

insertar,

case 08 9b:etoCola.imprimir!%* para agregar componentes al )ector brea;*

} para #uitar componentes del )ector eliminar, if!opcion&&?% brea;* }

capacidad, para obtener la capacidad mxima del )ector

cuenta, para obtener el n&mero de elementos actuales contenidos por el )ector >> 7 funcion principal .oid main!%{ clrscr!%* (l 'acer un anlisis muy detallado del problema planteado y al tratar de resol)er el mismo Cola ColaEnteros* mediante la <int> programacin clsica, )eremos #ue, si bien es cierto #ue se puede llegar a la probarCola !ColaEnteros%*

solucin, para lograrlo se tendran #ue establecer una serie de medidas #ue nos permitiern controlar de alguna manera detalles tales como: el total de elementos soportados por el }

)ector y el n&mero de elementos actuales contenidos por el )ector Por ejemplo, con la instruccin:
int .ector'+1()*

se crea un arreglo con capacidad para 128 componentes de tipo entero ('ora bien, el compilador sabe perfectamente #ue deber reser)ar un espacio de 128 enteros para la memoria del )ector, pero no se garantiza #ue cual#uier funcin trate de leer o escribir datos fuera de los limites del )ector !s decir, nuestro programa no podra saber el tama,o del )ector a menos #ue usaramos alg&n truco, por ejemplo usar el primer elemento del )ector para contener el tama,o del mismo Otra forma de alcanzar una solucin, sera #ue a cada una de las funciones #ue tengan #ue )er con el )ector se le pasar los parmetros: puntero de )ector y n&mero de elementos en el )ector, de tal manera #ue, por ejemplo, la funcin mostrar podra declararse como:
int mostrar!int ".ector, int cuenta%*

[editar] Un paso hacia adelante

0i continuamos en el mbito de la programacin clsica podemos dar un paso ms si es #ue nos )alemos de tipos estructurados ms elaborados Por ejemplo, podemos definir una estructura llamada )ector la cual posea los miembros: capacidad, cuenta y data como se muestra en seguida:
typedef int int int }* struct .ector { capacidad* cuenta* "data*

.e tal manera #ue podriamos escribir funciones #ue operen sobre un solo parmetro del tipo estructurado )ector Por ejemplo, la funcin mostrar podra declararse como:
int mostrar!.ector ".%*

!n este punto tendramos #ue detenernos y pensar en lo siguiente: "a estructura )ector $ definida arriba con typedef % es solamente un nue)o tipo de dato, es decir, podemos declarar tantas copias $ )ariables % de la misma como sean necesarias, pero carece de un m/todo constructor adecuado Por ejemplo, la declaracin:
.ector nombre$.ar*

es )lida siempre y cuando #ue el tipo )ector ya 'aya sido definido, pero la )ariable nombre9)ar contendr slo basura 'asta #ue no se establezcan los )alores adecuados para cada uno de sus miembros $ capacidad, cuenta y data %

[editar] Una mejor solucin

Para el tipo de problemas como en el ejemplo )ector y otros similares, surge la POO, misma #ue facilita en gran medida la solucin del mismo, pero a&n #ueda pendiente la resolucin a otro problema, es decir, 'asta a#u 'emos mencionado la estructura )ector como un contenedor de n&meros enteros, pero un )ector podra contener caracteres, n&meros de punto flotante y otros tipos estructurados: y los mismos algoritmos usados para $ mostrar, ordenar, buscar, etc % empleados en un )ector de enteros, tendran su aplicacin sobre )ectores de cual#uier tipo !s asi como surge lo #ue se conoce como P"(;<=""(0 o lo #ue es lo mismo, la programacin gen/rica

[editar] La clase ector desde la perspecti a de la POO

Con el objeti)o de mostrar en la prctica los conceptos #ue 'emos )enido mencionando presentaremos un pe#ue,a implementacin de la clase )ector 0e debe aclarar #ue la implementacin de la misma se 'ar para )ectores contenedores de datos tipo int solamente Para simplificar el ejemplo, para la clase )ector solamente se implementarn los m/todos mostrar$%, ordenar$% e insertar$%, asi como un m/todo constructor base y un m/todo destructor
#include <iostream> #include <cstdio> #include <ctime> usin7 namespace std* #define BECT9O$KEF#P@T$I/QE +12 class .ector { >> atributos int capacidad* int cuenta* int "data* public8 >> constructor base .ector!% { capacidad & BECT9O$KEF#P@T$I/QE* cuenta & (* data & ne< int'BECT9O$KEF#P@T$I/QE)* } >> destructor E.ector!% { delete') data* } >> desplie7a todos los elementos contenidos por el .ector .oid mostrar!% { for !int t & (* t < cuenta* t,,% cout << 6elemento 6 << t << 6, .alor 6 << data't) << endl* }

>> inserta un elemento al .ector int insertar!int d% { if !cuenta && capacidad% return =+* data'cuenta) & d* cuenta ,,* return cuenta* } >> ordena en forma ascendente los elementos del .ector .oid ordenar!% { int i, :, temp* int fin & cuenta* i & (* < ile !i < fin % { for ! : & i * : < fin=+* :,,% if ! data':) > data':,+) % { temp & data':)* data':) & data':,+)* data':,+) & temp* } fin ==* } }* }

#define R#S +( int main!% { .ector .* srand! time!NP@@% %* for !int r & (* r < R#S* r,,% ..insertar! rand!% T +((%* cout << 6Un.ector . sin ordenarUn6* ..mostrar!%* ..ordenar!%* cout << 6Un.ector . ordenadoUn6* ..mostrar!%* 7etc ar!%* return (*

[editar] Una plantilla para la clase ector

>na )ez #ue se llegado al entendimiento de la programacin estructurada asi como de la programacin orientada al objeto, se puede obser)ar #ue, si bien es cierto #ue ambas ofrecen soluciones a problemas fundamentales tambien es cierto #ue las soluciones se presentan como casos especializados !sta &ltima afirmacin la podemos ilustrar si nos

fijamos en el caso del programa presentado anteriormente, en dic'o programa se presenta la clase )ector como un contenedor especial para n&meros enteros $int%, a'ora bien, si prestamos a&n aun ms atencin podemos llegar a la conclusin de #ue todos los algoritmos o funciones aplicadas en la clase )ector pueden operar con cul#uier otro tipo de datos y, por lo tanto, la &nica diferencia sera el tipo de datos contenidos por el )ector .e tal manera #ue aparece lo #ue se llama generalizacin o programacin genrica y esta, a su )ez, nos permite la creacin de plantillas basadas en una lgica operatoria pre)iamente concebida Con el objeti)o de mostrar un ejemplo prctico retomaremos la clase )ector del programa de la seccin anterior y crearemos, a raiz del mismo, una plantilla "a plantilla resultante tendr la capacidad para crear )ectores de cual#uier tipo
#include <iostream> #include <cstdio> #include <ctime> usin7 namespace std* #define BECT9O$KEF#P@T$I/QE +12 template <class T> class .ector { >> atributos int capacidad* int cuenta* T "data* public8 >> constructor base .ector!% { capacidad & BECT9O$KEF#P@T$I/QE* cuenta & (* data & ne< T'BECT9O$KEF#P@T$I/QE)* } >> destructor E.ector!% { delete') data* } .oid mostrar!%* int insertar!T d%* .oid ordenar!%*

}*

>> implementaciVn del mWtodo mostrar template <class T> .oid .ector<T>88mostrar!% { for !int t & (* t < cuenta* t,,% cout << 6elemento 6 << t << 6, .alor 6 << data't) << endl* } >> implementaciVn del mWtodo insertar template <class T> int .ector<T>88insertar!T d% {

if !cuenta && capacidad% return =+* data'cuenta) & d* cuenta ,,* return cuenta*

>> implementaciVn del mWtodo ordenar template <class T> .oid .ector<T>88ordenar!% { T temp* int i, :, fin & cuenta* i & (* < ile !i < fin % { for ! : & i * : < fin=+* :,,% if ! data':) > data':,+) % { temp & data':)* data':) & data':,+)* data':,+) & temp* } fin ==* }

#define TEIT +( int main!% { >> prueba de un .ector de nXmeros de punto flotante .ector<double> .* srand! time!NP@@% %* for !int r & (* r < TEIT* r,,% ..insertar! !rand!% T +(% " (.5%* cout << 6Un.ector . sin ordenarUn6* ..mostrar!%* ..ordenar!%* cout << 6Un.ector . ordenadoUn6* ..mostrar!%* >> prueba de un .ector de nXmeros lon7 int .ector<lon7 int> .1* srand! time!NP@@% %* for !int r & (* r < TEIT* r,,% .1.insertar! !rand!% T +((% %* cout << 6Un.ector .1 sin ordenarUn6* .1.mostrar!%* .1.ordenar!%* cout << 6Un.ector .1 ordenadoUn6* .1.mostrar!%* 7etc ar!%* return (*

!structuras II

"ontenido
?ocultar@ 1 =ntroduccin o 1 1 Pilas o 0tacAs
o

1 1 1 Pila en arreglo esttico 1 1 2 Pila dinmica

1 2 Colas o Bueues

1 2 1 Cola en un arreglo esttico

1 3 Colas de doble enlace

Introduccin
*uc'os autores comienzan por definir los conceptos de estructura de datos a raiz de estructuras conocidas como listas !n el mismo contexto, suele suceder #ue a dic'as listas tambi/n se les conoce como secuencias y+o colecciones de datos Cay #ue decir #ue dic'os autores estn $en parte% en lo correcto, ya #ue una lista $de cual#uier tipo% es una estructura ideada con el propsito de albergar datos agrupados bajo un mismo nombre (l respecto, podemos pensar #ue las listas son como arreglos de datos, es decir, para 'acer una introduccin al manejo y programacin de listas encadenadas podemos tomar como punto de partida a los arreglos estticos !s as como en esta secccin se descubrir la forma de operacin de tres tipos com&nes de listas conocidas como: PIL#$, "OL#$ D %O&L! "OL# $$'#"(, )U!U!, %)U!U!% !n programacin, el uso de listas es una prctica tan extendida #ue lenguajes tales como $por ejemplo% Ea)a, Pyt'on y C++ soportan los mecanismos necesarios para trabajar con estructuras de: Fectores, Pilas, Colas, "istas, etc !n C++, los programadores #ue usen .e)GCpp $ Hloods'ed softIare G.e)GC++ % pueden apro)ec'ar las )entajas #ue ofrecen las 0<" $0tandard <emplates "ibraries% dentro de la cual se pueden encontrar plantillas para la manipulacin de listas tales como: Fectores, "istas, 0ets, *aps, etc Por otro lado, los usuarios de Horland C++ $ <urbo C++ )ersion 1 81 % pueden 'acer uso de la C"(00"=H, misma #ue posee las librerias para los propsitos mencionados

;ota: !n las siguientes secciones se presentarn seis programas, tres para simular listas
basadas en arreglos estticos y tres para simular listas por medio de enlaces dinmicos $punteros% !n cuanto al material incluido se debe 'acer las siguientes declaraciones:
3. Puesto "ue el material es puramente did%ctico, cada programa se escribe en un mismo arc!i'o. La idea es no perder de 'ista el ob*eti'o. Los entendidos sabr%n "ue normalmente se deben escribir arc!i'os de cabecera, arc!i'os de implementacion arc!i'os de prueba por separado.

7. Para cada una de las clases creadas en los programas se !an elegido nombres en ingles. La idea es "ue gran parte de la documentacin e implementacin referente a listas est% en dic!o idioma, as, se le da al estudiante la idea b%sica de como operar con las libreras soportadas por los compiladores 8e'9#pp, ,orlan #$$, otros. :. Igual, se debe obser'ar "ue los m+todos de las clases tienen nombres en ingles, "ue con el ob*eti'o de establecer cierta estandari)acin todas las clases poseen los mismos m+todos, aun"ue cada una de ellas implementa los mismos a su manera.

[editar] Pilas o $tac*s

Pna D/@# es una estructuras en donde cada elemento es insertado y retirado del tope de la misma, y debido a esto el comportamiento de un una pila se conoce como @/F9 !Xltimo en entrar, primero en salir %.

>n ejemplo de pila o stacA se puede obser)ar en el mismo procesador, es decir, cada )ez #ue en los programas aparece una llamada a una funcin el microprocesador guarda el estado de ciertos registros en un segmento de memoria conocido como $tac* $egment, mismos #ue sern recuperados al regreso de la funcin
[editar] Pila en arreglo esttico

!n el programa #ue se )er en seguida, se simula el comportamiento de una estructura de pila (un#ue en el mismo se usa un arreglo esttico de tama,o fijo se debe mencionar #ue normalmente las implementaciones 'ec'as por fabricantes y+o terceras personas se basan en listas dinmicas o enlazadas Para la implementacin de la clase 0tacA se 'an elegido los m/todos:
put!%, poner un elemento en la pila 7et!%, retirar un elemento de la pila empty!%, re7resa + !TOPE% si la pila esta .acia siFe!%, nXmero de elementos en la pila El atributo ID de la clase Itac; es el puntero de lectura>escritura, es decir, el ID indica la posiciVn dentro de la pila en donde la funciVn put!% insertar el si7uiente dato, y la posiciVn dentro de la pila de donde la funciVn 7et!% leer el si7uiente dato. Cada .eF Mue put!% inserta un elemento el ID se decrementa. Cada .eF Mue 7et!% retira un elemento el ID se incrementa.

!n el siguente ejemplo se analiza lo #ue sucede con el 0P $puntero de pila% cuando se guardan en la pila uno por uno los caracteres J(J, JHJ, JCJ y J.J Obser)e #ue al principio el 0P es igual al tama,o de la pila

"lenando la pila
ID Y ,===,===,===,===,===, Y Y Y Y Y Y ,===,===,===,===,===, ID Y ,===,===,===,===,===, Y Y Y Y Y # Y ,===,===,===,===,===,

al principio !lista .acia%

pus !J#J%* despues de

aber a7re7ado el primer elemento

ID Y ,===,===,===,===,===, Y Y K Y C Y B Y # Y ,===,===,===,===,===,

despues de

aber a7re7ado cuatro elementos

Faciando la pila
ID Y ,===,===,===,===,===, Y Y K Y C Y B Y # Y ,===,===,===,===,===,

pop!%* despues de

aber retirado un elemento

ID Y ,===,===,===,===,===, Y Y K Y C Y B Y # Y despues de aber retirado todos los elementos ,===,===,===,===,===, Nota8 obser.e Mue al final la lista est .acia, y Mue dic o estado se debe a Mue el puntero est al final de la pila y no al ec o de borrar fZsicamente cada elemento de la pila.

!jemplo: Pila basada en un arreglo esttico

#include <iostream. > #define IT#CA$I/QE 153 >" capacidad m-ima "> typedef c ar almacen'IT#CA$I/QE)* class Itac; {

int int int almacen

ID* >" puntero de lectura>escritura "> /TERI* >" nXmero de elementos en lista "> /TERI/QE* >" tama[o del elemento "> D/@#* >" el almacen ">

public8 >> constructor Itac;!% { ID & IT#CA$I/QE=+* /TERI & (* /TERI/QE & + } >> destructor EItac;!% {}* >" re7resa el nXmero de elementos en lista "> int siFe!% { return /TERI* } >" re7resa + si no ay elementos en la lista, o sea, si la lista est .acia "> int empty!% { return /TERI && (* } >" insertar elemento a la lista "> int put!c ar d% { if ! ID >& (% { D/@#'ID) & d* ID ==* /TERI ,,* } return d* } >" retirar elemento de la lista "> int 7et!% { if ! G empty!% % { ID ,,* /TERI ==* } return D/@#'ID)* } }* >> fin de clase Itac;

>> probando la pila. >> Nota8 obse.e cVmo los elementos se in7resan en orden desde la # la Q, >> y como los mismos se recupern en orden in.erso. int main!% { int d* Itac; s* >> s es un ob:eto !instancia% de la clase Itac;

asta

>> llenando la pila for !d&J#J* d<&JQJ* d,,% s.put!d%* cout << 6/tems &6 << s.siFe!% << endl* >> .aciando la pila < ile ! s.siFe!% % cout << !c ar%s.7et!% << 6 6* cout << 6UnDara terminar oprima <Enter>...6* cin.7et!%* return (* }

[editar] Pila dinmica

!n el siguiente programa se presenta una implementacin de una estructura dinmica tipo pila o stacA !s importante 'acer notar #ue, a diferencia de una pila basada en un arreglo esttico, una pila enlazadada dinmicamente no posee de forma natural el mecanismo de acceso por ndices, en ese sentido, el programador puede crear los algoritmos necesarios para permitir tal comportamiento !n la clase #ue presentaremos en el ejemplo no se 'a implementado el mecanismo de acceso por ndices, ya #ue la misma se presenta como una alternati)a para la simulacin de una pila o stacA >no de los puntos ms destacables en cuando al uso de listas enlazadas dinmicamente es el 'ec'o de crear estructuras conocidas como nodos >n nodo es una especie de esla)on $ similar al de una cadena de bicicleta %, es decir, cada nodo se enlaza con otro a tra)/s de un puntero #ue apunta a una estructura del mismo tipo #ue el nodo Por ejemplo, para crear una estructura de nodo para almacenar enteros y a la )ez para apuntar a otro posible nodo podemos emplear la sintaxis:
struct nodo { int data* nodo "si7uiente* }*

obser)e #ue con la declaracin anterior estamos creando el tipo estructurado nodo, mismo #ue posee a los miembros: data para guardar )alores enteros, y siguiente para apuntar o enlazar a un supuesto siguiente nodo Da #ue las listas dinmicas inicialmente se encuentran )acias, y ms a&n, una lista dinmica no posee una direccin establecida en tiempo de compilacin ya #ue las direccin de memoria #ue ocupar cada uno de los elementos se establecer en tiempo de ejecucin, entonces cmo determinar la condicin de )acio K !n nuestro ejemplo usaremos un contador $ =<!*0 % #ue dic'o sea de paso, si =<!*0 L 8, entonces la lista est )acia $ la condicin de )acio tambi/n podra determinarse al )erificar el 0P, es decir, si el 0P L ;>"", significa #ue la lista no posee elementos % (l 'acer un anlisis pre)io de los e)entos #ue acontecern en la pila y su puntero de lectura y escritura $0P, #ue en esta ocasin es una estructura tipo nodo%, se tiene lo siguiente:

3) Al principio la lista est% 'acia, en ese caso el SP es igual a N;LL consecuencia, el puntero ne0t tambi+n es N;LL.
ID & NP@@ ,======,======, Y \\\\ Y ne-t Y==> NP@@ ,======,======,

, en

7) 8espues de agregar el primer elemento la situacin se 'era asi(

ID & asi7nado + ,======,======, Y data Y ne-t Y==> NP@@ ,======,======,

:) 8espues de agregar otro elemento la situacin se 'era asi(

ID & asi7nado 1 + ,======,======, ,======,======, Y data Y ne-t Y==> Y data Y ne-t Y==> NP@@ ,======,======, ,======,======,

!jemplo: Pila basada en un arreglo dinmico

>"===============================================================, , e:emplo de una pila ! IT#CA % enlaFada dinmicamente , , , , #utor8 9scar E. Dalacios , , email8 oscarpalacios+]ya oo.com.m, , , , Ranifiesto8 , , Este pro7rama puede distribuirse, copiarse y modificarse de , , forma libre. , ,==============================================================="> #include <iostream> >>#include <conio. > usin7 namespace std* >" tipo de dato Mue contendr la lista "> typedef c ar K#T#$T^DE* >> declaraciNn de estructura nodo struct nodo { K#T#$T^DE data* nodo "ne-t* }* class Itac;Kin { >> atributos int /TERI* >" nXmero de elementos en la lista "> int /TERI/QE* >" tama[o de cada elemento "> nodo "ID* >" puntero de lectura>escritura ">

public8 >> constructor Itac;Kin!% 8 ID!NP@@%, /TERI!(%, /TERI/QE!siFeof!K#T#$T^DE%% {} >> destructor EItac;Kin!% {} >" a7re7ar componente a la lista "> K#T#$T^DE put!K#T#$T^DE .alor% { nodo "temp* temp & ne< nodo* if !temp && NP@@% return =+* temp=>data & .alor* temp=>ne-t & ID* ID & temp* /TERI ,,* return .alor* } int empty!% { return /TERI && (* } >" retirar elemento de la lista "> K#T#$T^DE 7et!% { nodo "temp* K#T#$T^DE d* if ! empty!% % return =+* d & ID=>data* temp & ID=>ne-t* if !ID% delete ID* ID & temp* /TERI ==* return d*

}* >> fin de la clase Itac;Kin >" punto de prueba para la clase Itac;Kin "> int main!% { >>clrscr!%* Itac;Kin s* K#T#$T^DE d* for !d&J#J* d<&JQJ* d,,% s.put!d%* < ile ! G s.empty!% % cout << !K#T#$T^DE%s.7et!% << 6 6*

cout << 6UnDara terminar presione <Enter>...6* cin.7et!%* return (*

[editar] "olas o )ueues

Pna cola sencilla es una estructura en donde cada elemento es insertado inmediatamente despues del Xltimo elemento insertado* y donde los elementos se retiran siempre por el frente de la misma, debido a esto el comportamiento de un una cola se conoce como F/F9 !primero en entrar, primero en salir%.

>n ejemplo a citar de cola es el comportamiento del buffer del teclado Cuando en el teclado se oprime una tecla, el cdigo del caracter ingresado es trasladado y depositado en una ar/a de memoria intermedia conocida como Mel buffer del tecladoM, para esto el microprocedador llama a una rutina especfica "uego, para leer el caracter depositado en el buffer existe otra funcin, es decir, 'ay una rutina para excribir y otra para leer los caracteres del buffer cada una de las cuales posee un puntero: uno para saber en donde dentro del buffer se escribir el siguiente cNdigo y otro para saber de donde dentro del buffer se leer el siguiente cdigo
[editar] Cola en un arreglo esttico

!n el programa #ue se )e en seguida, se simula el comportamiento de una estructura de cola simple (un#ue en el mismo se usa un arreglo esttico de tama,oo fijo se debe mencionar #ue normalmente las implementaciones 'ec'as por fabricantes y+o terceras personas se basan en listas dinmicas o dinamicamente enlazadas Para la implementacin de la clase Bueue se 'an elegido los m/todos:
put!%, poner un elemento en la cola 7et!%, retirar un elemento de la cola empty!%, re7resa + !TOPE% si la cola est .acia siFe!%, n_mero de elementos en la cola El atributo cabeFa de la clase `ueue es el puntero de lectura. El atributo cola de la clase `ueue es el puntero de escritura.

!s decir, la cola indica la posiciNn dentro de la lista en donde la funcin put$% insertar el siguiente dato, y la cabeza indica la posicin dentro de la lista de donde la funcin get$% leer el siguiente dato
Cada .eF Mue put!% inserta un elemento la cola se incrementa. Cada .eF Mue 7et!% retira un elemento la cabeFa se incrementa.

!n el siguente ejemplo se analiza lo #ue sucede con la cola y la cabeza $punteros de escritura y de lectura de la "ista% cuando se guardan en la cola uno por uno los caracteres J(J, JHJ, JCJ y J.J Obser)e #ue al principio: cola L cabeza L cero "lenando la cola
cola Y ,===,===,===,===,===, Y Y Y Y Y Y ,===,===,===,===,===, Y cabeFa cola Y ,===,===,===,===,===, Y # Y Y Y Y Y ,===,===,===,===,===, Y cabeFa

al principio

put!J#J%* despues de

aber a7re7ado el primer elemento

cola Y ,===,===,===,===,===, Y # Y B Y C Y K Y Y ,===,===,===,===,===, Y cabeFa

despues de

aber a7re7ado cuatro elementos

Faciando la cola
cabeFa Y ,===,===,===,===,===, Y # Y B Y C Y K Y Y ,===,===,===,===,===, cabeFa Y ,===,===,===,===,===, Y # Y B Y C Y K Y Y ,===,===,===,===,===,

antes de

aber retirado elementos

7et!%* despues de

aber retirado un elemento

cabeFa Y ,===,===,===,===,===, Y # Y B Y C Y K Y Y ,===,===,===,===,===, Y

al final despues de

aber retirado todos los elementos

cola

Obser)ese #ue al final el cabeza apunta 'acia el mismo elemento #ue la cola, es decir, la cola )uel)e a estar )acia Puesto #ue la cola #ue estamos proyectando reside en un arreglo esttico los componentes del arreglo a&n estan dentro de la misma, sal)o #ue para su recuperacin se debera escribir otro m/todo !n una cola dinmica $como se demostrar ms adelante% los elementos retirados de la misma se eliminan de la memoria y podra no ser posible su recuperacin posterior Nota: !n el programa #ue aparece en seguida, al tipo de lista implementado por la clase Bueue se le conoce como Mlista circularM debido al comportamiento de sus punteros !s decir si los m/todos para escribir o leer detectan #ue el puntero correspondiente 'a sobrepasado el tama,o mximo de elementos permitidos dentro de la cola, /ste es puesto a cero

!jemplo: cola en un arreglo esttico

>"===============================================================, , e:emplo de una cola !`PEPE% basada en un arre7lo esttico , , , , #utor8 9scar E. Dalacios , , email8 oscarpalacios+]ya oo.com.m, , , , Ranifiesto8 , , Este pro7rama puede distribuirse, copiarse y modificarse de , , forma libre. , ,==============================================================="> #include <iostream. > #define R#S$I/QE 153 >" capacidad m-ima "> typedef c ar almacen'R#S$I/QE)* class `ueue { int cabeFa* int cola* int /TERI* int /TERI/QE* almacen alma* >" >" >" >" >" puntero de lectura "> puntero de escritura "> nXmero de elementos en la lista "> tama[o de cada elemento "> el almacen ">

public8 >> constructor `ueue!% { cabeFa & (* cola & (* /TERI & (* /TERI/QE & +* } >> destructor E`ueue!% {} >> re7resa + !true% si la lista est .acia

int empty!% { return /TERI && (* } >> insertar elemento a la lista int put!int d% { if ! /TERI && R#S$I/QE% return =+* if ! cola >& R#S$I/QE% { cola & (* } alma'cola) & d* cola ,,* /TERI ,,* return d* } >> retirar elemento de la lista int 7et!% { c ar d* if ! empty!% % return =+* if ! cabeFa >& R#S$I/QE % { cabeFa & (* } d & alma'cabeFa)* cabeFa ,,* /TERI ==* return d* } >> re7resa el n_mero de elementos en lista int siFe!% { return /TERI* } }* >> fin de la clase `ueue

>> probando la cola int main!% { int d* `ueue M* for !d&J#J* d<&JQJ* d,,% M.put!d%* cout << 6/tems & 6 << M.siFe!% << endl* < ile ! M.siFe!% % { cout << !c ar%M.7et!% << 6 6* } cout << 6UnDara terminar oprima <Enter> ...6* cin .7et!%* return (*

!jemplo: cola en un arreglo dinmico

>"===============================================================, , e:emplo de una cola !`PEPE% basada en un arre7lo dinmico , , , , #utor8 9scar E. Dalacios ,

, email8 oscarpalacios+]ya oo.com.m, , , , Ranifiesto8 , , Este pro7rama puede distribuirse, copiarse y modificarse de , , forma libre. , ,==============================================================="> #include <iostream> usin7 namespace std* typedef c ar K#T#$T^DE* struct nodo { K#T#$T^DE data* nodo "ne-t* }* class `ueueKin { >> atributos int /TERI, /TERI/QE* nodo "cola, "cabeFa* public8 >> constructor `ueueKin!% 8 cola!NP@@%, cabeFa!NP@@%, /TERI!(%, /TERI/QE!siFeof!K#T#$T^DE%% {} >> destructor E`ueueKin!% {} >" a7re7ar componente a la lista "> K#T#$T^DE put!K#T#$T^DE .alor% { nodo "temp* temp & ne< nodo* if !temp && NP@@% return =+* /TERI ,,* temp=>data & .alor* temp=>ne-t & NP@@* if !cabeFa && NP@@% { cabeFa & temp* cola & temp* } else { cola=>ne-t & temp* cola & temp* } return .alor* } >> re7resa + !true% si la lista est .acia int empty!% { return /TERI && (* }

>" retirar elemento de la lista "> K#T#$T^DE 7et!% { nodo "temp* K#T#$T^DE d* if ! empty!% % return =+* d & cabeFa=>data* temp & cabeFa=>ne-t* if !cabeFa% delete cabeFa* cabeFa & temp* /TERI ==* return d*

}* >> fin de la clase `ueueKin >" punto de prueba "> int main!% { `ueueKin s* K#T#$T^DE d* >> llenando la cola for !d&J#J* d<&JQJ* d,,% { s.put!d%* cout << d << 6 6* } cout << endl* >> .aciando la cola < ile ! G s.empty!% % cout << !K#T#$T^DE%s.7et!% << 6 6* cout << 6UnDara terminar presione <Enter>...6* cin.7et!%* return (*

[editar] "olas de doble enlace

Pna cola doble es una estructuras en donde cada elemento puede ser insertado y recuperado por la parte del frente !cabeFa% o por la parte de atras !cola% de la lista. # diferencia de una cola sencilla, en donde solo se necesitan un mWtodo para leer y otro para escribir componentes en la lista, en una doble cola debe aber dos mWtodos para leer ! uno para leer por el frente y uno para leer por atras % y dos mWtodos para escribir ! uno para escribir por el frente y uno para escribir por atras %.

!n el programa #ue se )er en seguida, se simula el comportamiento de una estructura de cola doble en base a un arreglo esttico !n dic'o programa se declara e implementa la clase $%)ueue con los siguientes m/todos:
put$front!%, put$bac;!%, 7et$front!%, 7et$bac;!%, empty!%, siFe!%, poner un elemento en el frente de la cola poner un elemento en la parte tracera de la cola retirar un elemento de la parte frontal de la cola retirar un elemento de la parte tracera de la cola re7resa + !TOPE% si la cola est .acia nXmero de elementos en la cola

;ota: obser)e #ue para los m/todos put9front$% y get9front$% se 'ace uso de la funcin memmo)e$%, esto es necesario debido al 'ec'o de #ue put9front$% tiene #ue mo)er una posicin 'acia atras todos los elementos en la lista antes de insertar el componente indicado: por otro lado, la funcin get9front$% tiene #ue mo)er una posicin 'acia adelante a todos los elementos #ue le siguen al primer elemento

!jemplo: doble cola en un arreglo esttico

>"==================================================================, , e:emplo de una cola doble !K`PEPE% basada en un arre7lo est tico , , , , #utor8 9scar E. Dalacios , , email8 oscarpalacios+]ya oo.com.m, , , , Ranifiesto8 , , Este pro7rama puede distribuirse, copiarse y modificarse de , , forma libre. , ,=================================================================="> #include <iostream. > #include <mem. > >> por memmo.e >> usin7 namespace std* #define R#S$I/QE 153 #define t$error =+* typedef int K#T#$T^DE* >> m-imo nXmero de elementos typedef int almacen'R#S$I/QE)* class IK`ueue { >> atributos int itemsiFe* >> tama[o de cada elemento int items* >> nXmero de elementos int cola, cabeFa* >> punteros de lectura y escritura almacen alma* >> el almacen o arre7lo public8 >> constructor IK`ueue!% 8 cola!(%, cabeFa!(%, items!(%, itemsiFe!siFeof!K#T#$T^DE%% {} >> destructor EIK`ueue!% {}

int empty!% { return items && (* } int siFe!% { return items* } >" a7re7ar componente en la parte tracera de la lista "> K#T#$T^DE put$bac;!K#T#$T^DE .alor% { if !items && R#S$I/QE% return t$error* alma'cola) & .alor* items ,,* cola ,,* return .alor* } >" a7re7ar componente en la parte delantera de la lista "> K#T#$T^DE put$front!K#T#$T^DE .alor% { if !items && R#S$I/QE% return t$error* memmo.e!!.oid "%Lalma'cabeFa,+), !.oid"%Lalma'cabeFa), items"itemsiFe%* alma'cabeFa) & .alor* items ,,* cola ,,* return .alor* } >" retirar elemento de la parte frontal de la lista "> K#T#$T^DE 7et$front!% { K#T#$T^DE d* if ! empty!% % return t$error* items ==* cola ==* d & alma'cabeFa)* memmo.e!!.oid"%Lalma'cabeFa), !.oid"%Lalma'cabeFa,+), items"itemsiFe%* return d* } >" retirar elemento de la parte tracera de la lista "> K#T#$T^DE 7et$bac;!% { K#T#$T^DE d* if ! empty!% % return t$error* items==* cola ==* d & alma'cola)* return d*

}* >> fin de la clase IK`ueue >" punto de prueba ">

int main!% { IK`ueue s* K#T#$T^DE d* for !d&J#J* d<&JQJ* d,,% s.put$bac;!d%* < ile ! G s.empty!% % cout << !c ar%s.7et$front!% << 6 6* cout << 6UnDara terminar presione <Enter>...6* cin.7et!%* return (* }

>na cola doblemente encadenada es una estructuras en donde cada elemento puede ser insertado y recuperado por la parte del frente $cabeza% o por la parte de atras $cola% de la lista ( diferencia de una cola sencilla, en donde solo se necesita un puntero a un siguiente elemento, la estructura del nodo para una doble cola debe poseer un puntero a un posible siguiente elemento y un puntero a otro posible anterior elemento Por ejemplo, para crear una estructura de nodo con doble enlace para coleccionar n&meros enteros podemos usar la sintaxis:
struct nodo { int data* nodo "ne-t, "pre.* }*

Orficamente podemos imaginar la estructura anterior como:

,======,======,======, <==Y pre. Y data Y ne-t Y==> ,======,======,======,

!n el programa #ue se )er en seguida, se simula el comportamiento de una estructura de cola de doble enlace Para la implementacin de la clase ..#ueue en el programa se 'an elegido los m/todos:
put$front!%, poner un elemento en el frente de la cola put$bac;!%, poner un elemento en la parte tracera de la cola 7et$front!%, retirar un elemento de la parte frontal de la cola 7et$bac;!%, retirar un elemento de la parte tracera de la cola empty!%, re7resa + !TOPE% si la cola est .acia siFe!%, n_mero de elementos en la cola >"===============================================================, , e:emplo de una cola doblemente enlaFada !KMueue% basada en un , , arre7lo dinmico , , , , #utor8 9scar E. Dalacios , , email8 oscarpalacios+]ya oo.com.m, , , , Ranifiesto8 , , Este pro7rama puede distribuirse, copiarse y modificarse de ,

, forma libre. , ,==============================================================="> #include <iostream. > #include <conio. > >> usin7 namespace std* typedef c ar K#T#$T^DE* struct nodo { K#T#$T^DE data* nodo "ne-t, "pre.* }* class KKMueue { int itemsiFe, items* nodo "cola, "cabeFa* public8 >> constructor KKMueue!% 8 cola!NP@@%, cabeFa!NP@@%, items!(%, itemsiFe!siFeof!K#T#$T^DE%% {} >> destructor EKKMueue!% {} >" a7re7ar componente en la parte tracera de la lista "> K#T#$T^DE put$bac;!K#T#$T^DE .alor% { nodo "temp* temp & ne< nodo* if !temp && NP@@% return =+* temp=>data & .alor* items ,,* if !cabeFa && NP@@ % { temp=>ne-t & NP@@* temp=>pre. & NP@@* cabeFa & temp* cola & temp* } else { cola=>ne-t & temp* temp=>pre. & cola* cola & temp* cola=>ne-t & NP@@* } return .alor* }

>" a7re7ar componente en la parte frontal de la lista "> K#T#$T^DE put$front!K#T#$T^DE .alor% { nodo "temp* temp & ne< nodo* if !temp && NP@@% return =+* temp=>data & .alor* items ,,* if !cabeFa && NP@@ % { temp=>ne-t & NP@@* temp=>pre. & NP@@* cabeFa & temp* cola & temp* } else { cabeFa=>pre. & temp* temp=>ne-t & cabeFa* cabeFa & temp* cabeFa=>pre. & NP@@* } return .alor* } >> re7resa true si la lista est .acia int empty!% { return items && (* } >" retirar elemento de la parte frontal lista "> K#T#$T^DE 7et$front!% { nodo "temp* K#T#$T^DE d* if ! empty!% % return =+* items ==* d & cabeFa=>data* temp & cabeFa=>ne-t* if !cabeFa% delete cabeFa* cabeFa & temp* return d* } >" retirar elemento de la parte tracera de la lista "> K#T#$T^DE 7et$bac;!% { nodo "temp* K#T#$T^DE d* if ! empty!% % return =+* items==* d & cola=>data*

temp & cola=>pre.* if !cola% delete cola* cola & temp* return d*

}* >> fin de la clase KKMueue >" punto de prueba "> int main!% { clrscr!%* KKMueue s* K#T#$T^DE d* >> insertando elementos en la parte tracera for !d&J#J* d<&JQJ* d,,% s.put$bac;!d%* >> insertando en la parte delantera for !d&a* d>&(* d==%s.put$front!d,J(J%* >> .aciando la lista < ile ! G s.empty!% % cout << !K#T#$T^DE%s.7et$front!% << 6 6* cout << 6UnDara terminar presione <Enter>...6* cin.7et!%* return (* }