Estructuras

1 Sinopsis Las estructuras C++ son una herencia de C; existen (se implementaron) por compatibilidad hacia atrs con el cdigo del C clsico, pero en el contexto de C++ no tienen demasiado sentido ya que las clases ( 4 !!), un concepto mucho ms general, las engloban, de"ndolas arrinconadas como un caso particular de un mundo mucho ms rico y potente #!$ Nota% de hecho, las estructuras C++ son una especie de h&brido entre las estructuras C tradicionales (de las que son un supercon"unto) y las clases C++, de las que son una 'ariedad con propiedades muy espec&(icas )or e"emplo, todos los miembros son p*blicos ( 4 +a!)

,ealmente el programador C++ no deber&a necesitar nunca utili-ar estructuras como tales, ya que pueden ser sustituidas por clases de(inidas con ciertas peculiaridades .n concreto, las estructuras C pueden ser consideradas como un tipo especial de clases que no tienen m/todos; el acceso por de(ecto es p*blico, y para la clase base tambi/n es p*blico por de(ecto 0in embargo, puesto que las clases C++ disponen de tres tipos de modi(icadores de acceso% pblico, privado y protegido, el considerarlas como tales, permite un mayor control de acceso de las estructuras que el o(recido por el C clsico 1e hecho, el programador que quiera mentalmente sustituir la palabra struct por class (sabiendo que es un tipo particular de clase), no necesita realmente estudiar este cap&tulo, siempre naturalmente que cono-ca a (ondo el de las clases

2 .xisten circunstancias en que las estructuras son especialmente importantes y *tiles, ya sean consideradas en el sentido clsico de C, o en su 'ersin como clases Constituyen un medio excelente para agrupar un con"unto de elementos heterog/neos y mane"arlos como un todo, (acilitando as& el mane"o de datos comple"os )or e"emplo, las estructuras pueden ser pasadas como argumentos a (unciones o de'ueltas por estas 2ambi/n cuando se trata de almacenar y recuperar registros de datos en medios externos (disco por e"emplo) .n estos casos son especialmente idneas para escribir y recuperar in(ormacin heterog/nea en una sola operacin de lectura3escritura

3 Como tales casos particulares de clases, las estructuras son tipos nue'os de(inidos por el usuario (nue'os en el sentido de que no estn prede(inidos en el lengua"e), que se engloban dentro de la categor&a general de tipos deri'ados ,epresentan con"untos de miembros que pueden ser a su 'e- de tipo bsico ( 4 4 !) o derivado ( 4 4 4) 5con ciertas restricciones que se se6alarn ms tarde5 7dems tambi/n pueden ser miembros los campos de bits (este tipo no puede aparecer en ninguna otra parte 4 + 8)

.n otros lengua"es se les denomina registros (records); sus componentes se denominan 9miembros9, aunque en ocasiones tambi/n se suelen llamar 9campos9

7parte de estos mecanismos opcionales de acceso y de las di(erencias que se irn se6alando, la explicacin que sigue sobre la sintaxis y uso de estructuras es 'lida tanto para C como para C++

Sintaxis y reglas para estructuras en C/C++

En C/C++ se forma una estructura utilizando la palabra reservada struct, seguida por un campo etiqueta opcional, y luego una lista de miembros dentro de la estructura. La etiqueta opcional se utiliza para crear otras variables del tipo particular de la estructura:
struct campo_etiqueta{ tipo_miembro miembro_1; tipo_miembro miembro_2; tipo_miembro miembro_3; : : tipo_miembro miembro_n; };

Un punto y coma finaliza la definicin de una estructura puesto que sta es realmente una sentencia C/C++ . Algunos de los e emplos usan la estructura:
struct stbarco{ char sztipo[iString1 +i!u""_char#; char szmo$e"o[iString1 +i!u""_char#; char sztitu"ar[iString2%+i!u""_char#; int ianio; "ong int "horas_motor; &"oat &precio'enta; };

En un programa, podemos asociar una variable con una estructura utilizando una sentencia similar a la siguiente:
struct stbarco stbarco_usa$o;

La sentencia define stbarco_usa$o de tipo struct stbarco. La declaracin requiere el uso del campo etiqueta de la estructura. !i esta sentencia est" contenida dentro de una funcin, entonces la estructura, llamada stbarco_usa$o, tiene un "mbito local a esa funcin. !i la sentencia est" contenida fuera de todas las funciones de programa, la estructura tendr" un "mbito global. Es posible declarar una variable usando esta sinta#is:
struct stbarco{ char sztipo[iString1 +i!u""_char#; char szmo$e"o[iString1 +i!u""_char#; char sztitu"ar[iString2%+i!u""_char#; int ianio; "ong int "horas_motor; &"oat &precio'enta; } stbarco_usa$o;

Aqu$ la declaracin de variable va antes del punto y coma final. %uando se asocia slo una variable con el tipo estructura, el campo etiqueta puede ser eliminado, por lo que ser$a posible escribir:
struct { char sztipo[iString1 +i!u""_char#; char szmo$e"o[iString1 +i!u""_char#; char sztitu"ar[iString2%+i!u""_char#; int ianio; "ong int "horas_motor; &"oat &precio'enta; } stbarco_usa$o;

Arreglos
Definicin 1 Un arreglo se compone de elementos de igual tamao almacenados linealmente en posiciones de memoria consecutiva.

!e puede acceder a cada elemento de datos individual utilizando un sub$ndice, o $ndice, para seleccionar uno de los elementos. En C/C++ , un arreglo no es un tipo de datos est"ndar& es un tipo agregado compuesto de cualquier otro tipo de datos. Los arreglos se pueden definir usando tipos de datos mi#tos debido a que se supone que todos los elementos son del mismo tama'o. (uesto que todos los elementos son del mismo tama'o y ya que este )ec)o se utiliza para ayudar a determinar cmo localizar un elemento dado, resulta que los elementos son almacenados en localidades de memoria contiguas. Lo m"s importante a tener en cuenta es: El nombre de un arreglo es visto por el compilador como un puntero*constante al primer elemento del arreglo. Esto es muy importante: a+ El nombre del arreglo es visto como un tipo puntero, y m"s espec$ficamente, b+ un puntero constante *significa una direccin de memoria bloqueada para el primer elemento de un arreglo*. (or e emplo, aunque una declaracin de arreglo toma la frma genrica:
(ipo_)"emento*rra+ !ombre*rra+ [ !umero,e)"ementos #

El compilador ve la declaracin como

(ipo_)"emento*rra+ - const !ombre*rra+ . /!ombre*rra+[%#;

(or esta razn, un identificador de arreglo no puede ser usado nunca como un valor-i ,valor izquierdo+. Los valores izquierdos representan variables que su contenido puede ser alterado por el programa& frecuentemente aparecen a la izquierda de las sentencias de asignacin. !i los nombres de arreglo fueran variables izquierdos permitidos, el programa podr$a cambiar sus contenidos.
&"oat Sa"arios,e)mp"ea$os[0a1_emp"ea$os#; 2 2

2 Sa"arios,e)mp"ea$os . 3 4352%;

El efecto )ar$a cambiar la direccin inicial del propio arreglo.

Declaraciones de un arreglo
La sinta#is de declaracin de arreglos es:
tipo nombre_arreg"o [numero_$e_e"ementos#;

Los siguientes son dos e emplos de declaraciones de arreglos v"lidas en C/C++ :

int Coor$ena$as,e6anta""a[ #; /-7n arreg"o $e enteros -/ char 8,Compania[2%#; /-7n arreg"o $e 2% caracteres -/

Figura 1: Arreglo Coor$ena$as,e6anta""a con ndices de desplazamiento vlido

En la figura - se muestra el primer arreglo que fue declarado con el tipo de n.meros enteros, llamado Coor$ena$as,e6anta""a, ocupa en memoria / localidades de memoria contiguas, cada una de ellas capaz de almacenar un n.mero entero. Actualmente es com.n que los n.meros enteros sean de 01 bits, esto )ace que el arreglo Coor$ena$as,e6anta""a ocupe bits

2o se permite utilizar nombres de variables dentro de los corc)etes. (or esto no es posible evitar la especificacin del tama'o del arreglo )asta la e ecucin del programa. La e#presin debe ser un valor constante, para que el compilador sepa e#actamente cu"nto espacio de memoria tiene que reservar para el arreglo. Una buena pr"ctica de programacin es usar constantes predefinidas.
9$e&ine Coor$ena$as_0a1 2% 9$e&ine (amano_0a:_Compania_8$ 1 int Coor$ena$as,e6anta""a[Coor$ena$as_0a1#;

char 8,Compania[(amano_0a:_Compania_8$#;

El uso de constantes predefinidas garantiza que futuras referencias al arreglo no e#cedan el tama'o del arreglo definido.

Arreglos multidimensionales
El trmino dimensin representa el nmero de ndices utilizados para referirse a un elemento particular en el arreglo. Los arreglos de ms de una dimensin se llaman arreglos multidimensionales.
// $os,im2cpp -/ 9inc"u$e ;iostream< 9$e&ine num=i"as 3 9$e&ine numCo"umnas int main >int argc? char - const arg'[#@ { int $esp=i"a? $espCo"umna? $esp"azamiento? mu"tip"o? $espCa"cu"a$os[num=i"as#[numCo"umnas#; &or>$esp=i"a.%;$esp=i"a;num=i"as;$esp=i"a++@ &or>$espCo"umna.%;$espCo"umna;numCo"umnas;$espCo"umna++@{ $esp"azamiento.numCo"umnasA$espCo"umna; mu"tip"o.$esp=i"a; $espCa"cu"a$os[$esp=i"a#[$espCo"umna#. >$esp=i"a+1@-$espCo"umna+$esp"azamiento mu"tip"o; }; &or>$esp=i"a.%;$esp=i"a;num=i"as;$esp=i"a++@{ st$::cout;;B=i"a actua": B;;$esp=i"a;;BCnB; st$::cout;;B,istancia re"ati'a $es$e "a base: B;;BCnB; &or>$espCo"umna.%;$espCo"umna;numCo"umnas;$espCo"umna++@ st$::cout;;B B ;;$espCa"cu"a$os[$esp=i"a#[$espCo"umna# ;;B B; st$::cout;;BCnCnB; } } } return %;

El programa utiliza dos ciclos &or para calcular e inicial cada uno de los elementos del arraglo a su respectiva distancia relativa desde la base. El arreglo creado tiene 3 filas y / columnas por fila, )aciendo un total de 14 elementos enteros. Los arreglos multidimensionales son almacenados de forma lineal en la memoria de la computadora. Los elementos en los arreglos multidimensionales est"n agrupados desde el $ndice m"s a la derec)a )acia el centro. En el e emplo anterior, fila -, columna - ser$a el

elemento 0 del arreglo almacenado. Aunque el c"lculo del desplazamiento aparece un poco dif$cil, es referenciado f"cilmente cada elemento del arreglo. La salida del programa anterior es:
=i"a actua": % ,istancia re"ati'a $es$e "a base: % 1 2 3 3 =i"a actua": 1 ,istancia re"ati'a $es$e "a base: D 4 E 5 =i"a actua": 2 ,istancia re"ati'a $es$e "a base: 1% 11 12 13 13 =i"a actua": 3 ,istancia re"ati'a $es$e "a base: 1 1D 14 1E 15 $os$im has e1ite$ Fith status %2

Recursin
Un tema fundamental para los pr#imos temas es el de recusrin. La recursin es muy importante tanto en mate"ticas como em computacin, pues se usa recursin para definir procedimientos autosimilares.
Definicin 6 Decimos que un objeto es recursivo si en su definicin se nombra a s mismo.

En programacin, una funcin es recursiva si en el "mbito de esa funcin )ay una llamada a s$ misma, C/C++ permite esta clase de acciones. Los algoritmos recursivos dan elegancia a las soluciones de los problemas. Un e emplo cl"sico es el factorial de un n.mero. Una manera de definir el factorial de un n.mero es:

es decir, el producto de todos los n.meros enteros menores o guales que l, lo que se puede resolver f"cilmente con una funcin iterativa, esto es, una funcin con un ciclo que itere suficientes veces, incrementando un valor y entonces ir almacenando en una variable el resultado de esas multiplicaciones.

Una implementacin de esta definicin iterativa es:

>1@ >2@ >3@ > @ >D@ >4@ >E@ int i?n; "ong $oub"e 'a"or*c; 'a"or*c.12%; st$::cout ;; B!umero entero:B; st$::cin<< n; &or>i.1; i;.n; i++@ 'a"or*c . 'a"or*c-i; st$::cout;;B)" &actoria" $e B;;n;;B es:B;;'a"or*c;

El ciclo principal es en la l$nea ,5+. 2o )ay ning.n truco )asta aqu$. La .nica observacin importante es en la l$nea ,1+ en donde se declara el tipo "ong $oub"e para el valor del resultado, la razn para tal accin es que el n.mero factorial crece muy r"pido y a.n con entradas en el rango de los caracteres ,)asta 1//+, el factorial es muy grande. Este procedimiento computacional no )ace uso de tcnicas especiales empleadas para tratar n.meros grandes. !in embargo una solucin m"s elegante es usar la definicin recursiva, y esta es:

El programa en C/C++ es el que se muestra a continuacin:

> 1@ $oub"e &actoria">$oub"e a@{ > 2@ i& >a;.1@ return 12%; > 3@ e"se return >a -&actoria">aA12%@@; } > 3@ > @ int main >int argc? char - const arg'[#@ { > D@ $oub"e n; > 4@ st$::cout ;; B!umero entero:B; > E@ st$::cin<< n; > 5@ st$::cout;;B)" &actoria" $e B;;n;;B es: B;; &actoria">n@; >1%@ return %; }

Aqu$ )ay varias cosas que se'alar, en primer lugar se )a creado una nueva funcin, a diferencia de la definicin iterativa en donde era suficiente traba ar en el programa principal. Esta funcin se llama &actoria" ,como era de suponerse+, y empieza su encabezado en la l$nea ,-+. All$ mismo en la misma l$nea ,-+, es de notar que )emos emplado a)ora el tipo $oub"e tanto para el tipo devuelto como para el tipo del argumento, a diferencia de la versin iterativa en donde emple"bamos tipos diferentes. La razn es que al iniciar la recursin el argumento es del tipo devuelto, asi que deben ser del mismo tipo. %ada llamada recursiva genera una entrada a una pila, en donde se guardan ,como elementos+ los estados generales del sistema al momento de )acer la llamada, entonces, cuando se termina la funcin se recupera una entrada de la pila. En la figura -6 ilustra cmo funciona la recursividad cuando se intenta obtener el &actoria"> @.

Figura 16: Recursividad cuando se ejecuta

&actoria"> @

La serie Fibonacci
Una de las series m"s famosas es sin duda alguna la serie de 7ibonacci:

Un poco de observacin es sufucuente para encontrar que cualquier n.mero ,a partir del tercero de la serie, osea el segundo -+ es igual a la suma de los dos n.meros anteriores. 8aremos en primer lugar la versin iterativa. En este algoritmo deseamos encontrar el * simo n.mero de la serie 7ibonacci. As$ si el resultado del algoritmo debe ser & si el resultado debe ser . La versin iterativa empieza desde los primeros -9s, sum"ndolos y encontrando el tercero, luego para encontrar el cuarto n.mero se suman el tercero ,recin encontrado+ y el segundo, y as$ en adelante )asta encontrar el n.mero buscado.
9inc"u$e ;iostream< int main >int argc? char - const arg'[#@ { int i?n?&ib?&ib1?&ib2?&ib1; st$::cout;;B7n numero entero:B; st$::cin<<n; &ib1.2; &ib2.1; i.3; i&>>n..1@GG>n..2@@ &ib.1; e"se{ $o{ &ib . &ib1 + &ib2; &ib1 . &ib1; i++; &ib1 . &ib; &ib2 . &ib1; }Fhi"e>i;n@; } st$::cout ;; BCn)" B;;n;;BAesimo numero $e

"a serie =ibonacci es: B;;&ib; return %; }

La definicin recursiva para encontrar todos los es:

primeros n.meros de la serie 7ibonacci

En el siguiente cdigo, la solucin que propone la recursividad resulta en una programacin elegante, aunque costosa. El cdigo que )ace esto es:
> 1@ > 2@ > 3@ > 3@ > @ > D@ > 4@ > E@ > 5@ >1%@ >11@ >12@ >13@ >13@ >1 @ >1D@ 9inc"u$e ;iostream< //.................... int &ib>int 'a"@{ i& >>'a"..1@GG>'a"..2@@ return 1; e"se return >&ib>'a"A1@+&ib>'a"A2@@; } //.................... int main >int argc? char - const arg'[#@ { int n; st$::cout;;B!umero entero:B; st$::cin<<n; st$::cout;;BCn)" B;; n ;;BAesimo numero &ibonacci es: B;; &ib>n@; return %; }

%omo regla general, cualquier algoritmo recursivo se puede reescribir en un algoritmo iterativo. La venta a de tener un algoritmo iterativo es que no se usa una pila para guardar llamadas a la misma funcin de manera recursiva, esto es una venta a porque el espacio de memoria destinado al uso de la pila es generalmente limitado, de manera que cuando se )acen demasiadas funciones push seguramente llegar" el momento en que la pila ::se desborde99, que por cierto es un trmino usado en computacin para decir que ya no )ay m"s espacio disponible en la pila. ARCHIVOS SEC E!CIALES En estos arc)ivos, la informacin slo puede leerse y escribirse empezando desde el principio del arc)ivo. Los arc)ivos secuenciales tienen algunas caracter$sticas que )ay que tener en cuenta: -. La escritura de nuevos datos siempre se )ace al final del arc)ivo.

1. (ara leer una zona concreta del arc)ivo )ay que avanzar siempre, si la zona est" antes de la zona actual de lectura, ser" necesario ;rebobinar; el arc)ivo. 0. Los fic)eros slo se pueden abrir para lectura o para escritura, nunca de los dos modos a la vez. Esto es en teor$a, por supuesto, en realidad % no distingue si los arc)ivos que usamos son secuenciales o no, es el tratamiento que )agamos de ellos lo que los clasifica como de uno u otro tipo. (ero )ay arc)ivos que se comportan siempre como secuenciales, por e emplo los fic)eros de entrada y salida est"ndar: stdin, stdout, stderr y stdau#. <omemos el caso de stdin, que suele ser el teclado. 2uestro programa slo podr" abrir ese fic)ero como de lectura, y slo podr" leer los caracteres a medida que estn disponibles, y en el mismo orden en que fueron tecleados. Lo mismo se aplica para stdout y stderr, que es la pantalla, en estos casos slo se pueden usar para escritura, y el orden en que se muestra la informacin es el mismo en que se env$a. Un caso especial es stdau#, que suele ser el puerto serie. <ambin es un arc)ivo secuencial, con respecto al modo en que se leen y escriben los datos. !in embargo se un fic)ero de entrada y salida. <raba ar con arc)ivos secuenciales tiene algunos inconvenientes. (or e emplo, imagina que tienes un arc)ivo de este tipo en una cinta magntica. (or las caracter$sticas f$sicas de este soporte, es eviente que slo podemos tener un fic)ero abierto en cada unidad de cinta. %ada fic)ero puede ser le$do, y tambin sobrescrito, pero en general, los arc)ivos que )aya a continuacin del que escribimos se perder"n, o bien ser"n sobreescritos al crecer el arc)ivo, o quedar" un espacio vac$o entre el final del arc)ivo y el principio del siguiente. Lo normal cuando se quer$a actualizar el contenido de un arc)ivo de cinta a'adiendo o modificando datos, era abrir el arc)ivo en modo lectura en una unidad de cinta, y crear un nuevo fic)ero de escritura en una unidad de cinta distinta. Los datos le$dos de una cinta se editan o modifican, y se copian en la otra secuencialmente. %uando traba emos con arc)ivos secuenciales en disco )aremos lo mismo, pero en ese caso no necesitamos dos unidades de disco, ya que en los discos es posible abrir varios arc)ivos simultaneamente. En cuanto a las venta as, los arc)ivos secuenciales son m"s sencillos de mane ar, ya que requieren menos funciones, adem"s son m"s r"pidos, ya que no permiten moverse a lo largo del arc)ivo, el punto de lectura y escritura est" siempre determinado. En ocasiones pueden ser .tiles, por e emplo, cuando slo se quiere almacenar cierta informacin a medida que se recibe, y no interesa analizarla en el momento.

(osteriormente, otro programa puede leer esa informacin desde el principio y analizarla. Este es el caso de arc)ivos ;log; o ;diarios; por e emplo, los servidores de las p"ginas =E> pueden generar una l$nea de te#to cada vez que alguien accede al una de las p"ginas y las guardan en un fic)ero secuencial.

:include ;stdio h<

struct pro'eedores = int long cl>pro'; char ra-on>social#?@$; char domicilio#?@$; char tele(ono#!+$; char contacto#?@$; int long credito; Apro'e; struct contr = int long cl>pro'; char ra-on>social#?@$; char domicilio#?@$; char tele(ono#!+$; char contacto#?@$; int long credito; Acontrol; 'oid main('oid) = BCL. Darch!,Darch4,Darch?; int codigo,cla'e,contro,contro!E@,existeE@,contar,contae,contbr,contbi; contarE@;contaeE@;contbrE@;contbiE@; clrscr(); 33codigos% ! 57lta 4 5Fa"a print((9GHue operacion desea reali-arI (0alirE@)9); gets(codigo); do= i((codigoEE@) breaJ; sKitch(codigo) = case !% arch!E(open(9c%LLpro'eedores txt9,9at+9); print((9Cngrese codigo%9); gets(pro'e cl>pro'); ((lush(stdin); print((9Cngrese ra-on%9); gets(pro'e ra-on>social); print((9Cngrese domicilio9);

gets(pro'e domicilio); print((9Cngrese tele(ono%9); gets(pro'e tele(ono); print((9Cngrese contacto%9); gets(pro'e contacto); print((9Cngrese credito9); scan((9Md9,Npro'e credito); reKind(arch!); Khile(O(eo((arch!)) = (read(Ncontrol,si-eo((control),!,arch!); i((control cl>pro'OEpro'e cl>pro') = existeE@; A else existeE!; A; i((existeEE@) = (Krite(Npro'e,si-eo((pro'e),!,arch!); print((97lta ,eali-ada9); contarEcontar+!; A else = arch4E(open(9c%LLincorrectos txt9,9at+9); (Krite(Npro'e,si-eo((pro'e),!,arch4); print((97lta .xistente9); contaeEcontae+!; A (close(arch!); (close(arch4); case 4% arch!E(open(9c%LLpro'eedores txt9,9r+9); arch4E(open(9c%LLtemporal txt9,9at+9); arch?E(open(9c%LLincorr4 txt9,9at+9); print((9GHue registro desea eliminarI9); scan((9Md9,Ncla'e);

Khile((read(Npro'e,si-eo((pro'e),!,arch!)EE!) = i((cla'eOEpro'e cl>pro') = (Krite(Npro'e,si-eo((pro'e),!,arch4); controE@; A

else contro!E!; A; i((controEE@ NN contro!EE@) = print((9LnFa"a Cnexistente9); contbiEcontbi+!; A i((controEE@ NN contro!EE!); = print((9LnFa"a reali-ada9); contbrEcontbr+!; A (close(arch!); (close(arch4); (close(arch?); remo'e(9c%LLpro'eedores txt9); rename(9C%LLtemporal txt9,9C%LLpro'eedores txt9); A print((9LnGHue operacion desea reali-arI9); scan((9Md9,Ncodigo); AKhile(codigoOE@); A registros

Un registro es una estructura cuyos componentes pueden ser de diferente tipo. (ara declarar un tipo registro se debe incluir el nombre y el tipo de cada componente del mismo. En C"" se usa la palabra reservada struct para indicar que el tipo que se est" definiendo es un registro o estructura. Los campos de un registro pueden ser de cualquier tipo, incluyendo arrays y registros y son llamados campos o variables miembro que pueden ser accedidas individualmente mediante notacin 9.9 7ormalmente, podemos definir un registro de la siguiente manera: ;(ipoHegistro<::. struct ;nombre(ipo< I{I { ;tipo< ;nomJar< {, ;tipo< ;nomJar<}; } I}I; Algunos Ejemplos: const char =8!C*, . char>%@; const int 0*:C*, . 2%; typedef char (Ca$ena[0*:C*,+1#; // 0*:C*, caracteres + =8!C*, struct (&echa { int $ia? mes? anho; }; struct (6ersona { (Ca$ena nombre? ape""i$o1? ape""i$o2; int e$a$; (Ca$ena ni&;

(&echa &echa_nacimiento; } Las declaraciones de variables se realizan normalmente, es decir: (6ersona per; (&echa &1; Los nombres de los campos de un registro son locales a l, por lo que no )ay conflicto con otros nombres usados en el mdulo. Una referencia a un campo de un registro consiste en el nombre de la variable registro y el nombre del campo, separados por un punto, por e emplo: per.edad ? 04& Un registro completo puede aparecer en cualquier parte de una sentencia de asignacin y como par"metros de procedimientos, por e emplo: per.fec)a@nacimiento ? f-&

Aeamos a continuacin algunos de los algoritmos cl"sicos de ordenacin y b.squeda. y sus posibles implementaciones en %BB.
// CUEPROS DE PROCEDIMIENTOS Y FUNCIONES void Kusque$aSecuencia">int 1? (Jector '? int ini? int &in? int /pos? bool /encontra$o@ { pos . ini; encontra$o.false; while > >pos ;.&in@ // >Lencontra$o@ @ { if >'[pos#..1@ { encontra$o.true; } else { ++pos; } } } void Kusque$aKinaria>int 1? (Jector '? int ini? int &in? int /pos? bool /encontra$o@ { encontra$o.false; while > >ini ;.&in@ // >Lencontra$o@ @ { pos . >ini+&in@/2; if >'[pos#..1@ { encontra$o.true; } else if >1 ; '[pos#@ { ini . pos +1; } else { &in . posA1; } } } void Mr$enacion8nserccion>(Jector /'?int ini? int &in@ { int i? pos? au1; for>i.ini+1;i;.&in;++i@ { au1 . '[i#; pos . buscar_posicion>au1? '? ini? iA1@; abrir_hueco>'? pos? i@; '[pos#.au1; } } void Mr$enacionSe"eccion>(Jector /'?int ini? int &in@ { int i?pos; for>i.ini;i;&in;++i@ { pos . 6osicionmenor)"emento>'?i?&in@;

intercambia>'[i#?'[pos#@; } } void Mr$enacion8ntercambio>(Jector /'?int ini? int &in@ { int i?N?au1; bool intercambio; intercambio. true; i.ini; while> >i;.&inA1@ // >intercambio@ @ { intercambio . false; for>N.ini;N;.&inA1;++N@ { if >'[N#<'[N+1#@ { intercambio. true;

Laboratorio de Programacin 1A E.T.S. . n!orm"tica #estin $os% Luis Pastrana &rincones ' ())( (
intercambia>'[N#?'[N+1#@; } } ++i; } } int buscar_posicion>int au1? (Jector '? int ini? int &in@ { int i; i . ini; while> >i;.&in@ // >'[i#;au1@ @ { ++i; } return i; } void abrir_hueco>(Jector /'? int ini? int &in@ { int i; for>i.&in;i<.ini+1;AAi@ { '[i# . '[iA1#; } } void intercambia>int /1? int /+@ { int t; t . 1; 1 . +; + . t; } int 6osicionmenor)"emento>(Jector '?int ini? int &in@ { int i?menor; menor . ini; for>i.ini+1;i;.&in;++i@ { if >'[i#;'[menor#@ { menor . i; } } return menor; }