PII ModuloI Archivos v3

INSTITUTO DE TECNOLOGIA O.R.T.
Instituto incorporado a la enseñanza Oficial (A-763)
POGRAMACIÓN II Año 2008
MÓDULO I .........................................................................................................................................2
Introducción ....................................................................................................................................................................................... 3
Archivos .............................................................................................................................................................................................. 3
¿Qué son los archivos?................................................................................................................................................................. 3
¿Para qué uso un archivo?........................................................................................................................................................... 3
Organización de Archivos .............................................................................................................................................................. 4
Modo de Acceso................................................................................................................................................................................ 4
Archivos Secuenciales .................................................................................................................................................................... 4
Lectura y grabación de datos ........................................................................................................................................................ 5

Operaciones básicas con archivos .............................................................................................................................................. 5
Abrir archivo .................................................................................................................................................................................... 6
Abrir archivo para lectura ......................................................................................................................................................... 6
Abrir archivo para escritura ...................................................................................................................................................... 7
Determinar la condición de fin de archivo (EOF)....................................................................................................................... 7
Leer un registro............................................................................................................................................................................... 7
Grabar un registro .......................................................................................................................................................................... 8
Cerrar el archivo ............................................................................................................................................................................. 8
Procesamiento de datos................................................................................................................................................................ 9
Corte de Control .............................................................................................................................................................................. 11
Apareo de Archivos........................................................................................................................................................................ 16
Síntesis del Módulo I...................................................................................................................................................................... 22
Autoevaluación................................................................................................................................................................................ 22
Elaboración
Carlos Bruschetti
Nelson Ciffoni
Este material pertenece a la materia Programación II, de la Carrera de Analista de Sistemas de Computación del
INSTITUTO DE TECNOLOGÍA ORT.
Todos los derechos reservados. No esta permitida la reproducción total o parcial de este apunte, ni su tratamiento informático, ni
la transmisión de ninguna forma o por cualquier medio, ya sea electrónico, mecánico, por fotocopia, por registro u otros métodos,
sin el permiso previo de los titulares.
1ra edición Diciembre de 2007.
Programación 2 / Módulo I Pág. 1

MÓDULO I
Introducción y orientaciones para el estudio
En el desarrollo de este módulo abordaremos:
Conceptos generales de archivos

Procesamiento de archivos secuenciales
Técnica de Corte de control
Procesos de apareo de archivos secuenciales
Objetivos
Pretendemos que al finalizar de estudiar esta Unidad, el alumno logre:
Comprender la comunicación entre la memoria de la computadora y los dispositivos de

almacenamiento permanente.
Aplicar la técnica de corte de control y el proceso de apareo de archivos secuenciales para
la resolución de problemas.
Aclaraciones previas al estudio

En este módulo, usted encontrará:
Contenidos
Conceptualizaciones centrales
Bibliografía
Referencia de material bibliográfico recomendado
Actividades
Usted debe tener presente que los contenidos presentados en el módulo no ahondan
profundamente en el tema, sino que pretenden ser un recurso motivador, para que a
través de la lectura del material, la bibliografía sugerida, y el desarrollo de las
actividades propuestas alcance los objetivos planteados en el presente módulo.
Cada módulo constituye una guía cuya finalidad es facilitar su aprendizaje.

Introducción
En este módulo vamos a trabajar con archivos. Qué es un archivo y para qué sirve. Cuáles son sus
usos más corrientes. Mencionaremos los distintos tipos de organización de archivos y nos
centraremos en los archivos de organización secuencial.
También revisaremos las operaciones básicas sobre archivos, el tema del procesamiento de datos
y la técnica de programación llamada corte de control. Por último analizaremos el proceso de
apareo de archivos secuenciales y desarrollaremos una estrategia de solución.
Archivos
¿Qué es un archivo? ¿Para qué uso un archivo?
Estas son algunas preguntas que nos hacemos cuando comenzamos a abordar el tema del manejo
de archivos.
¿Qué son los archivos?

Es un grupo de datos estructurados, que son almacenados en un medio magnético, y puede ser
accedido para su uso por medio de una computadora.
Hablamos de grupo de datos estructurado. Generalmente cada componente de este grupo de

datos se denomina registro. Entendemos un archivo como una sucesión lógica de registros.
A su vez un registro está formado por campos y constituye una unidad de información (referida por
ejemplo a un cliente, a un alumno, etc.). Estos campos son la unidad mínima de información del
registro. Estos campos se diferencian por el significado o sentido dado a cada uno.
Si el dato correspondiente un campo de un registro no toma el mismo valor para registros distintos
(por ejemplo el N° de matrícula en un archivo que contiene los alumnos de un determinado curso),
diremos que la factibilidad es 0 o 1 para el N° de matrícula. Esto significa que un N° de matrícula
dado puede aparecer a los sumo en un registro del archivo.
Hablamos de factibilidad 0/N para un campo, si en el archivo puede haber hasta N registros con el
mismo valor para ese campo. Por ejemplo el campo Nota para un archivo de alumnos de un curso
tiene factibilidad 0/N.
¿Para qué uso un archivo?

Generalmente, un archivo es usado para acceder a información que se usa frecuentemente, o para
almacenar un gran volumen de información que va a ser usada por distintas personas o distintas
áreas de una organización.
Encontramos a nuestro alrededor varios ejemplos de utilización de archivos: los archivos de

errores o de “log”, es un ejemplo conocido en los ámbitos informáticos; la información de un padrón
electoral, se encuentra en un archivo, donde cada registro corresponde a una persona con todos
sus datos (documento de identidad, domicilio, ocupación, etc.); el listado de alumnos de una
facultad también se encuentra en un archivo.
Organización de Archivos
El término organización de archivos se aplica a la forma en que se estructuran los registros sobre
el soporte magnético (disco, cinta,..) durante su grabación.
Podemos hacer una breve enumeración de las formas básicas de organización de archivos:
secuencial, relativa y secuencial indexada.
En la organización secuencial los registros se van grabando unos a continuación de los otros, en el
orden que se van dando de alta, mientras que en la organización relativa los registros se graban en
las posiciones que les corresponda según el valor que guarden en el campo clave.
El campo clave permite identificar unívocamente al registro. Ejemplos de campos clave son el DNI
para un archivo de personas, el código para archivos de productos o clientes, la matrícula para
archivos de alumnos.
En la organización secuencial indexada los registros se graban inicialmente en forma secuencial, y
además se utilizan tablas que permiten localizar un registro de acuerdo a su clave; además se
utilizan espacios de almacenamiento para guardar registros que se agregan y no pueden ubicarse
secuencialmente.
La forma en que se organiza un archivo determina el modo de acceso al mismo.
Modo de Acceso
El modo de acceso se refiere al procedimiento que se debe seguir para situarse en un registro
determinado para realizar una operación de lectura o grabación del mismo.
El modo de acceso puede ser secuencial o directo. En el modo de acceso secuencial para llegar a
un registro es necesario pasar por todos los anteriores, mientras que en el modo de acceso directo
se puede llegar directamente a un registro conociendo únicamente el valor del campo clave.
El modo de acceso directo se puede llevar a cabo de varias formas:
1. La posición que ocupa el registro dentro del fichero coincide con el contenido de la clave.
2. Calculando la posición que ocupa el registro en el fichero mediante una transformación del
contenido del campo clave (acceso aleatorio - Hashing).
3. Mediante el uso de tablas de índices. La localización de un registro se hace buscando en la
tabla de índices el valor del campo clave y obtenemos la posición en que está grabado el
registro dentro del fichero (acceso indexado - Keyed).
Para decidir cuál es la mejor organización hay distintos criterios a tener en cuenta: rápido acceso,
fácil actualización, economía de almacenamiento, fácil mantenimiento.
Archivos Secuenciales
La organización secuencial es la forma más simple de almacenamiento de información en un
medio magnético. Los registros están organizados de manera secuencial, es decir uno detrás del
otro y con una marca a continuación del último que indica el final del archivo. Esta marca se la
conoce con el nombre de End Of File (EOF).
La lectura se realiza desde el primer registro, pasando por cada uno de los restantes hasta llegar al
final, sin posibilidad de retroceder en el recorrido, o de saltear aleatoriamente algún registro.
Este tipo de organización no permite la eliminación de registros ni la inserción en cualquier lugar,

salvo al final. Para poder resolver la inserción de registros se utilizan algoritmos llamados apareo
de archivos que a partir del archivo original y un archivo de novedades generan un nuevo archivo
actualizado que luego reemplazará al original.
Los archivos de organización secuencial se utilizan típicamente para el procesamiento de datos por
lotes, o procesamiento batch, donde todos los registros deberán ser procesados. También suelen
utilizarse en procesos donde se debe almacenar la información a medida que se recibe para que
posteriormente otro programa la analice, es por ejemplo el caso de los archivos de log donde se
guarda cronológicamente información acerca de alguna actividad.
Lectura y grabación de datos

Para trabajar con archivos en el lenguaje de programación C++, debemos contar con 2 variables.
En la primera de ellas se almacenará la información acerca de la ubicación del archivo en el
dispositivo magnético, y la segunda variable deberá ser una estructura en donde se almacenarán
los datos del registro del archivo.
Antes de comenzar a hablar de estas variables, vamos a hacer una pequeña referencia al
concepto de puntero; más adelante lo profundizaremos.
¿Qué es un puntero? Un puntero (o apuntador) es una variable que hace referencia a una región
de memoria; en otras palabras es una variable cuyo contenido es una dirección de memoria.
En el caso de lectura y grabación de archivos, decimos que contamos con dos variables. La
primera de ellas es un puntero que indica la posición en el medio magnético donde se va a realizar
la operación de lectura o de escritura. O sea, este puntero indica dónde se encuentra el próximo
registro a leer, en el caso en que estemos leyendo datos del archivo, o dónde se grabará el
siguiente registro, en el caso que estemos escribiendo datos.
Este puntero es la variable que relaciona la ubicación física del archivo (en el medio magnético),
con el nombre lógico con el que se identifica el archivo en el programa. Cuando el programa hace
referencia al nombre lógico, el sistema interpreta esta asociación y sabe el lugar físico del
dispositivo magnético donde debe leer o grabar.
La otra variable deberá ser una estructura que almacenará un registro del archivo. En el caso de
leer datos, esta variable recibirá el registro que acabamos de leer y en el caso de escribir,
debemos asignarle los datos que queremos guardar en el archivo.
Operaciones básicas con archivos

Para operar con archivos, es necesario conocer algunas operaciones básicas para el manejo de
los mismos. Las operaciones que soportan la mayoría de los lenguajes de programación son:
Abrir archivo, Cerrar archivo, Grabar registro, Leer registro, Fin de archivo, Borrar registro (no se
usa en archivos secuenciales).
A continuación comentamos y desarrollamos estas operaciones; los tipos de dato usados no están
declarados en C++ aunque sus nombres son suficientemente “explicativos”, dejamos al lector esta
tarea.
Abrir archivo
Abrir archivo para lectura

void AbrirArchivoDatos (srt40 ubicacion, str2 tipoApertura, File * &ArchivoDatos, bool &pudeAbrir)
En el procedimiento de apertura de archivos, pasamos 4 parámetros:
Ubicación indica el nombre físico del archivo (el nombre que tiene en el medio magnético).
TipoApertura indica en qué forma se va a abrir este archivo. Si vamos a abrir el archivo en modo
“lectura” , debemos indicar si la lectura se hará sobre un archivo de texto (rt, read text), o sobre un
archivo binario (rb, read binary).
ArchivoDatos es el puntero que va a ir moviéndose por el archivo. En el momento de la apertura,

en modo lectura, el puntero se sitúa en el primer registro del archivo.
PudeAbrir es una variable booleana, que retornará TRUE si fue posible abrir el archivo, o FALSE
en el caso de no poder abrirlo. Generalmente, los casos en que falla la apertura del archivo, es
porque no se encontró el archivo en el lugar físico que se indicó.
Nota: En esta asignatura, y para simplificar los diagramas asumiremos que siempre es posible abrir
el archivo, dejando para la práctica en máquina este control.
La implementación de esta rutina en lenguaje C++ sería de la siguiente forma:
{
ArchivoDatos = fopen (ubicacion, tipoApertura);
if (ArchivoDatos == NULL)
{
cout << "No se pudo Abrir el Archivo de Datos\n";
pudeAbrir = FALSE;
}
else
{
pudeAbrir = TRUE;
}
}
Y la llamada o invocación en el diagrama seria, por ejemplo:

Abrir archivo para escritura

En el caso que abramos un archivo para grabar datos, la variable puntero ArchivoDatos recibirá la
información del lugar donde se grabará el próximo registro y creará una entrada en el dispositivo
magnético para el nuevo archivo, con el nombre pasado en el parámetro ubicacion.
El parámetro tipoApertura ahora indica si se grabará un archivo de texto (wt) o un archivo binario
(wb).
Generalmente, los casos en que falla la apertura de un archivo, es porque no encontró el archivo
en el lugar físico indicado, o porque el dispositivo magnético se encontraba protegido contra
escritura.
El desarrollo del procedimiento y la llamada en el diagrama son los mismos que para lectura.
ATENCIÓN: Cuando se abre un archivo para escritura, en el caso que el archivo ya exista, se
reemplazará por el nuevo, perdiendo el anterior.
Determinar la condición de fin de archivo (EOF)

Para determinar la condición de fin de archivo cada vez que se realiza una lectura del archivo hay
que evaluar si devolvió la marca de fin de archivo (EOF) o los datos en la estructura del registro.
Esto se puede implementar con una variable booleana que devolverá TRUE en el caso que
encuentre la marca de EOF, o FALSE en caso contrario.
En lenguaje C++ contamos con una función llamada feof que evalua la condición de fin de archivo,
y devuelve 0 si está sobre la marca de fin de archivo y 1 si no lo está.
int feof(ArchivoDatos)
Leer un registro
void LeerArchivoDatos (FILE * &aDatos, ty_reg &sRegDatos, bool &bFin)

En el procedimiento de lectura de archivos, pasamos 3 parámetros:
aDatos es el puntero al archivo a leer
sRegDatos variable con la estructura del registro del archivo, es el patrón para leer el archivo. En
esta variable el procedimiento de lectura entrega el registro leído.
bfin indica si el archivo llegó al final, o sea, si encontró la marca de EOF (TRUE), o no.(FALSE)
void LeerArchivoDatos (FILE * &aDatos, ty_reg &sRegDatos, bool &bFin)

{
fread (&sRegDatos, sizeof(ty_reg), 1, aDatos);
if feof (aDatos)
bFin = TRUE;
else
bFin = FALSE;
}
Grabar un registro
void GrabarRegistroDatos (FILE * &aDatos, ty_reg sRegDatos)
En el procedimiento de escritura de archivos, pasamos sólo 2 parámetros:
aDatos es el puntero al archivo a leer
sRegDatos variable con la estructura del registro del archivo, es el patrón para grabar el archivo.
En esta variable se almacenan los datos a grabar en el archivo.
void GrabarRegistroDatos (FILE * &aDatos, ty_reg sRegDatos)

{
fwrite (&sRegDatos, sizeof(ty_reg), 1, aDatos);
}
Cerrar el archivo
void CerrarArchivoDatos (FILE * &aDatos)

void CerrarArchivoDatos (FILE * &aDatos)

{
fclose (aDatos);
}
Cuando se cierra un archivo, éste queda no disponible para su uso en el programa. Esta operación
“corta” el vínculo establecido entre el programa que usa el archivo y los datos almacenados en una
memoria externa o auxiliar (el archivo); también se graba en el archivo el último bloque que está en
memoria.
Procesamiento de datos
Al momento de procesar los datos almacenados en un archivo, debemos leer y procesar un
registro por vez, de la misma forma que lo haríamos si los datos se ingresan por teclado.
Para poder controlar el fin del archivo debemos leer la marca de EOF y de esa manera controlar el
ciclo de lectura.
Como cada lenguaje de programación maneja a su manera el EOF, vamos a generalizar la

solución utilizando un procedimiento para la lectura de los datos, como vimos en el ejemplo
anterior, que se encargará de controlar una variable booleana que indicará el fin del archivo.
A continuación veamos un ejemplo de lectura y escritura de archivos.
Supongamos un programa que lee desde un archivo los datos de inscripción de un alumno, y que
luego de validarlos, si la validación es OK lo graba en el maestro de alumnos, y si la validación es
errónea, lo graba en un archivo de errores. De esta forma, podemos utilizar el mismo
procedimiento Grabar ya que el formato del registro es el mismo tanto para el archivo de datos de
inscripción, como para el archivo de errores.
Mostraremos primero los prototipos de los procedimientos que vamos a utilizar, y a continuación el
diagrama de este proceso.
Suponemos declarados las variables y tipos correspondientes, los nombres que utilizamos son
suficientemente representativos.
/*Declaración de prototipos*/
void AbrirArchivo (srt40 ubicacion, str2 tipoApertura, File * &ArchivoDatos, bool &pudeAbrir)
void LeerregistroNovedades (FILE * &Arch, ty_reg &registro, bool &bFin)

int validoNovedades (ty_reg registro)
void GraboArch (FILE * &Arch, ty_reg registro)
void CerrarArchivo (FILE * &Arch)

El procedimiento será el siguiente:
AbrirArchivo (sUbicNov, “rb”, aNovedad, bPude)
AbrirArchivo (sUbicMae, “wb”, aMaestro, bPude)

Archivos de Entrada
AbrirArchivo (sUbicErr, “wb”, aErrores, bPude)
LeerRegistroNovedades (aNovedad, RegNov, bFinNov) Archivo de Salida
!bFinNov El formato del registro

es el mismo para el
GrabarArchivo (aMaestro, GrabarArchivo (aErrores, archivo de entrada y
el archivo de salida
RegNov) RegNov)
LeerRegistroNovedades (aNovedad, RegNov, bFinNov)
CerrarArchivo (aNovedad)
CerrarArchivo (aMaestro)
CerrarArchivo (aErrores)
Si observamos el diagrama, existen dos llamadas al procedimiento de lectura, la primera es la

llamada para leer el primer registro del archivo que de existir nos permitirá entrar en el ciclo para
procesarlo y continuar leyendo el resto.
En caso que el archivo esté vacío, la variable bFinNov volverá con TRUE y por lo tanto no
entraremos al ciclo; a continuación veremos la importancia de esta primer lectura adelantada.
Aclaración: De aquí en adelante, y por una cuestión de simplicidad en el procedimiento para abrir
un archivo, indicaremos sólo el modo de apertura y el nombre lógico del archivo, omitiendo el
nombre físico. Por ejemplo:
AbrirN (“rb”, aNotas)
Abre para lectura en forma binaria el archivo aNotas.
Es importante recordar que en la implementación es necesario indicar también la ubicación del

archivo y pasar el parámetro lógico o booleano para indicar si fue posible abrir el archivo o no.
En este contexto asumimos que siempre es posible abrir el archivo.

Corte de Control
El corte de control es una técnica de programación muy utilizada que permite resolver
determinadas situaciones en las cuales es necesario agrupar los registros almacenados en el
archivo de acuerdo a la información almacenada en uno o más campos.
Remontándonos a un ejercicio típico de Algoritmos y Estructura de Datos I, supongamos el

siguiente enunciado:
Confeccionar un programa que procese la información de las ventas de una distribuidora de

chocolates que tiene 20 sucursales en todo el país y cuenta con 10 vendedores como máximo en
cada sucursal. Para ello nos informan por cada venta realizada, los siguientes datos:
• Nro Factura (15 Caracteres)

• Cod Sucursal (Entero)
• Nro vendedor (Entero)
• Importe (Real).
El programa debe informar:
• Para cada sucursal, cuál fue el importe total vendido por cada vendedor.
• Cuál fue la sucursal que más vendió.
Una solución a este ejercicio sería armar una matriz de 20 filas que representarán a las sucursales,
por 10 columnas que representarán a los vendedores y por cada venta ingresada se actualizará
una celda de la matriz acumulando el importe vendido.
De esta manera tendríamos toda la información para que al finalizar el proceso, recorriendo la
matriz podamos mostrar los resultados pedidos.
Ahora supongamos que en lugar de ese enunciado tenemos este otro:
Confeccionar un programa que procese la información de las ventas de una distribuidora de

chocolates que tiene sucursales en todo el país. Para ello nos informan por cada venta realizada y
ordenado por sucursal y vendedor, los siguientes datos:
• Nro Factura (15 Caracteres)

• Cod Sucursal (Entero)
• Nro vendedor (Entero)
• Importe (Real)
El programa debe informar:
• Para cada sucursal, cuál fue el importe total vendido por cada vendedor.
• Cuál fue la sucursal que más vendió.
A diferencia del ejercicio anterior, no contamos con la información de cuántas sucursales y

vendedores hay; por lo que nos resultará imposible ir acumulando la información de las ventas en
una matriz dado que no podemos dimensionarla. Pero nos informan que “los datos están
ordenados por sucursal y vendedor” y esta es la clave para poder resolver el problema.
En el caso en que la información esté ordenada por el mismo criterio que nos están pidiendo
informar, se puede aplicar la técnica de corte de control para agrupar los datos y de esta manera
poder informar de acuerdo a lo pedido.
Supongamos el siguiente juego de datos para procesar:
Como podemos observar, si los datos están ordenados, todas las ventas del vendedor 1 de la
sucursal A van a estar juntas, por lo tanto podríamos tener una única variable para acumular las
ventas de los vendedores.
Esta variable la inicializaríamos en 0 antes de procesar las ventas del vendedor 1 de la sucursal A
y cuando cambia el vendedor, mostramos lo que acumulamos en esa variable, que para el ejemplo
sería 83, y la volvemos a poner en 0 para acumular las ventas del siguiente vendedor.
De esta forma, nos alcanza con tener una única variable para todos los vendedores, no importa
cuántos fuesen.
Lo mismo podríamos hacer para las sucursales, si queremos saber cuál es la sucursal que más
vendió, podemos tener una variable que mientras la sucursal que leemos sea la A, vaya
acumulando las ventas y cuando aparece una nueva sucursal, comparamos el acumulado de esa
sucursal con el máximo que tenemos hasta el momento (reemplazándolo si corresponde) y
volvemos a inicializar la variable para hacer lo mismo con las siguiente sucursal.
Esta técnica de resolución es la que llamamos corte de control y se implementa de la siguiente

manera:
Cada grupo o jerarquía que necesitemos procesar, va a necesitar de un ciclo donde procesemos
los datos de ese grupo, luego, para controlar este ciclo necesitaremos una variable que
previamente reciba el valor actual del dato por el cual queremos agrupar y en cada vuelta del ciclo
vamos a estar comparando el nuevo dato leído con el contenido de esta variable para ver si
cambió.
Al comenzar cada ciclo, deberemos inicializar también todas las variables que necesitamos para
ese grupo y al finalizar cada ciclo mostraremos los resultados de la actualización de esas variables.
Cada uno de estos ciclos que armamos y anidamos se llama nivel del corte de control y como
dijimos antes que cada agrupamiento necesita de un ciclo, vamos a tener tantos niveles de corte
como agrupamientos sean necesarios.
En el ejemplo anterior en el que tenemos que agrupar por sucursal y vendedor vamos a tener 2
niveles de corte de control.
A continuación el esquema clásico de un corte de control de 2 niveles:
Aclaración: Vamos a notar que en algunos procedimientos hay “puntos suspensivos”. Esto se debe
a que como es un diagrama genérico, se indican con puntos suspensivos los parámetros que se
pasarían en cada llamada a un procedimiento de acuerdo a un problema dado.

InicioGeneral (bFin, …)
AbrirDatos (aDatos, “rb”)
LeerArch (aDatos, sReg, bFin)
!bFin
clave1Ant sReg.clave1
InicioCorte1 (…...)
(!bFin) && (clave1Ant == sReg.clave1)
clave2Ant sReg.clave2
InicioCorte2 (…...)
(!bFin) && (clave1Ant == sReg.clave1) &&
(clave2Ant == sReg.clave2)
Proceso de los Datos (…...)
LeerArch (aDatos, sReg, bFin)
FinCorte2 (…...)
FinCorte1 (…...)
Cerrar (aDatos)
FinGeneral (….…)
Observemos que:
En el diagrama vemos 3 ciclos mientras, el primero es para controlar el fin de los datos y los
dos siguientes para los 2 niveles de corte.
Previo a cada nivel de corte existe un procedimiento para inicializar todas las variables
correspondientes a ese nivel y al final existe otro procedimiento para utilizar los resultados
obtenidos dentro del corte. Los resultados se pueden informar por pantalla, imprimir mediante
una impresora o grabarse en un archivo para otro proceso.
A continuación el diagrama de la solución al ejercicio aplicando corte de control:

Para poder aplicar la técnica de corte de control, los datos deben estar ordenados por los
campos que queremos agrupar.
• Se debe utilizar el esquema de lectura adelantada para que con la primera lectura se
puedan inicializar las variables que guardan los datos anteriores.
• La primera lectura debe hacerse fuera de todo ciclo y las siguientes siempre en el ciclo más
interno.
• Cada nivel de corte está compuesto de 3 partes, la inicialización de todas las variables a
utilizar en ese nivel, el ciclo donde procesamos los datos y el fin del corte donde se utilizan
los datos almacenados en las variables que se inicializaron y procesaron previamente.
• A medida que se agregan niveles de corte, las condiciones de los ciclos mientras (while) se
van sumando. En el primer ciclo, que es el que controla el fin de los datos, solo tenemos la
condición de fin de ciclo. En el siguiente ciclo, que corresponde al primer nivel de corte,
debemos controlar que no cambie el dato por el cual estamos agrupando, pero también que
nos e terminen los datos. Y así sucesivamente.

Actividades:
• Realizar el seguimiento del diagrama de corte de control con los datos de prueba y analizar
los resultados
Apareo de Archivos
El apareo de archivos es un proceso muy común en archivos secuenciales, en el cual se trabaja

con dos o más archivos de entrada, que deben estar ordenados por la misma clave (campo del
registro). La característica principal de este proceso, es que una vez procesados los archivos que
intervienen en el apareo, en general queda como resultado un solo archivo, producto del
procesamiento de los archivos de entrada.
Son procesos de apareo:

Intercalación o mezcla (merge): a partir de dos archivos de igual estructura, ordenados por un
mismo campo, se obtiene un archivo que contiene los registros de ambos y que mantiene el
ordenamiento.
Por ejemplo: Obtener un archivo único de asistentes a un evento, ordenado por DNI, a partir de la
información registrada en cada una de las 2 entradas habilitadas. Notar que tanto los archivos de
entrada, como el resultante estarán ordenados por DNI y tendrán factibilidad 0/1 por ese campo.
Intersección: a partir de dos archivos de igual estructura, se obtiene un archivo en el que

figuran todos los registros comunes a ambos, (también podrían ser los no comunes).
Por ejemplo: Generar el archivo de personas que obtuvieron su registro de conductor, a partir de la
información almacenada en los 2 archivos donde se grabaron los datos de las personas que
aprobaron el examen teórico y el examen práctico respectivamente. Notar que tanto los archivos
de entrada, como el resultante estarán ordenados por DNI y tendrán factibilidad 0/1 por ese campo.
El archivo de salida tendrá un registro por cada persona cuyos datos figuraban en ambos archivos
de entrada (aprobó el examen teórico y el práctico).
Actualización: se procede a la actualización de uno o más campos, a partir de un archivo

maestro y un archivo de novedades, ambos ordenados por el mismo campo (aunque no
necesariamente con la misma estructura de registro). Como resultado del proceso se genera un
archivo maestro actualizado. Observar que la cantidad de novedades para cada registro del
maestro puede ser ninguna, 1 o varias, dependiendo del proceso (factibilidad 0/n), mientras que
el campo clave del archivo maestro a actualizar tendrá factibilidad 0/1.
Por ejemplo: Actualizar el archivo de los alumnos de un curso, cargando las notas parciales
entregadas por los profesores. En este caso el archivo de alumnos es el maestro y tendrá
factibilidad 0/1 por Número de matrícula. A su vez, en el archivo con las novedades de las notas,
para cada alumno se podrán informar ninguna, 1 o más notas parciales (factibilidad 0/n por
Número de matrícula, donde n es la cantidad de notas informadas para un alumno). Notar que
ambos archivos de entrada (maestro y novedades), deben estar ordenados por Número de
matrícula para posibilitar el apareo (todas las notas para un alumno vienen “juntas”). El archivo de
salida del proceso (archivo de alumnos actualizado contendrá la misma cantidad de registros que
el archivo de alumnos leído y tendrán factibilidad 0/1 por ese campo.
Si bien en este módulo no abordaremos en detalle este problema, que será motivo de análisis más
adelante, mencionamos que un ejemplo clásico de apareo de archivos son los famosos ABM de
novedades, donde se procesan las Altas, Bajas y Modificaciones sobre un archivo maestro. Dichas
Altas, Bajas y Modificaciones vienen informadas en un archivo de novedades, ordenadas por la
misma clave que el archivo maestro. La clave es el campo que permite identificar el registro.
En este proceso, el archivo resultante es un archivo maestro actualizado, y si corresponde, un
archivo con los errores del proceso. El archivo maestro actualizado puede contener registros
nuevos (altas), registros modificados y también no contener registros que estaban en el maestro de
entrada por haber sido dados de baja.
En un proceso de apareo de actualización, se puede actualizar cualquier

campo, menos el campo clave.
Analizaremos un proceso de apareo mediante la resolución del siguiente problema:
Las inscripciones para concurrir a una conferencia deben realizarse personalmente en alguna de
las dos sedes habilitadas a tal fin, una en la ciudad de Buenos Aires y otra en la ciudad de La
Plata. En cada sede se han registrado los inscriptos consignando para cada uno: número de DNI,
apellido y nombre, teléfono y mail. Ambos archivos de inscriptos son ordenados por DNI (tienen
factibilidad 0/1 por este campo), y remitidos para su procesamiento.
Debemos obtener un archivo de inscripción, ordenado por DNI, que también tendrá factibilidad 0/1
por este campo, con todas las personas inscriptas. Si una persona se anotó en ambas sedes, debe
tener un solo registro en el archivo de inscripción unificado.
Comenzamos por declarar las estructuras necesarias para la resolución del problema y luego
analizaremos la estrategia de resolución y completaremos si es necesario.
//suponemos declarados con typedef los tipos str20 y str15 como cadenas de caracteres de la
longitud indicada.
// estructura del registro para los 3 archivos
typedef struct ty_rInsc{
int DNI;
str20 ApyN;
str15 mail;
str15 tel;
}
Ahora declaramos los registros y los archivos
void main() {
FILE * aInscBA; //archivo de inscriptos en BA
FILE * aInscLA; //archivo de inscriptos en La Plata
FILE * aInscU; //archivo de inscripción unificado
ty_rInsc rInscBA; // para leer el archivo aInscBA

ty_rInsc rInscLP; //para leer el archivo aInscLP
Para resolver el problema, obviamente comenzaremos por abrir los archivos aInscBA y aInscLP
para lectura y aInsc para grabación. Luego iremos leyendo los registros de ambos archivos de
entrada, ordenados por DNI, volcando en el archivo de salida los registros de inscripción de forma
tal que resulten ordenados por DNI y que no haya registros repetidos en el archivo de salida.
Por el momento postergamos la cuestión de cómo controlar el fin del proceso, aunque sabemos
que nuestro trabajo terminará cuando no haya más registros para leer en ninguno de los 2 archivos
de entrada.
Comenzaremos por leer un registro de cada archivo de entrada, la idea es ir procesando
“simultáneamente” los archivos aInscBA y aInscLP, comparando las claves del registro de cada
uno y obrando en consecuencia.
Analicemos qué significan los posibles resultados de comparar rInscBA.DNI con rInscLP.DNI.
(1) Si rInscBA.DNI < rInscLP.DNI La persona se inscribió en Buenos Aires

Debemos:
grabar el registro rInsBA en el archivo aInscU
leer un registro del archivo aInscBA
(2) Si rInscBA.DNI > rInscLP.DNI La persona se inscribió en La Plata
Debemos:
grabar el registro rInscLP en el archivo aInscU
leer un registro del archivo aInscLP
(3) Si rInscBA.DNI == rInscLP.DNI La persona se inscribió en Buenos Aires y en La Plata
Debemos:
grabar el registro rInscBA en el archivo aInscU
(notemos que en este caso es indistinto desde qué
registro de entrada grabar ya que ambos tienen el
mismo DNI, corresponden a la misma persona, y no
tiene sentido inscribirla 2 veces)
leer un registro del archivo aInscBA
leer un registro del archivo aInscLP
Las acciones indicadas en la tabla anterior deberán realizarse mientras haya registros (esto es
inscriptos) en alguno de los 2 archivos de entrada.
¿Qué debemos hacer si no hay más inscriptos en el archivo de aInscLP, pero quedan inscriptos en
aInscBA?
Piense ANTES de continuar leyendo…

Debemos grabar todos los registros restantes del archivo aInscBA en el archivo de salida (aInsc),
procediendo como en (1) del cuadro anterior, hasta alcanzar el fin del archivo aInscBA.
Análogamente si no hubiera más inscriptos en el archivo aInscBA, pero quedaran registros sin
procesar en aInscLP, estos registros deberían grabarse en el archivo aInsc, procediendo como en
el caso (2) del cuadro anterior.
Por último, si se alcanza el fin de archivo en ambos archivos de entrada simultáneamente, es
porque los últimos registros de cada uno tienen igual DNI, caso (3) del cuadro anterior.
Retomamos aquí la cuestión del control del fin del proceso; por lo visto recién, si al alcanzar el fin
de uno de los archivos de entrada, asignáramos al campo DNI (clave) de su registro un valor
suficientemente grande (por ejemplo en este caso 999999999), el DNI de los registros del archivo
que no finalizó resultaría siempre menor que este valor. Por lo tanto se grabaría el archivo de
salida y se volvería a leer del archivo que aun tiene registros, y así hasta alcanzar el fin de este
archivo también.
Si cuando se alcanza el fin del archivo que termina en segundo lugar, procedemos de la misma
forma, asignando un valor suficientemente grande al campo DNI, ya tenemos la condición que
controla el ciclo del proceso de apareo.
Mientras que alguno de los archivos no haya alcanzado el fin, continuamos ciclando, y recién
salimos cuando ambas claves tienen el valor 999999999, cuando ambos archivos alcanzaron el fin:
(rInscBA.DNI != 999999999) || (rInscLP.DNI != 999999999)
Ejecutar las acciones indicadas en la tabla anterior, esto es,

comparar las claves de los registros leídos y obrar en
consecuencia.
Ahora sólo restaría cerrar todos los archivos del proceso.

Observemos que será necesario modificar el procedimiento de lectura, ya que en este caso no
devolverá un valor lógico o booleano indicando si se alcanzó el fin de archivo. En caso de alcanzar
el fin del archivo asignará ese valor suficientemente grande al campo clave del registro.
Ese valor suficientemente grande que asignamos al campo clave se denomina cota superior. Una
cota es un valor que sirve de límite (superior o inferior) para un conjunto de valores, y que no
pertenece al conjunto en cuestión.
Una cota superior debe ser mayor que todos los valores posibles del campo que está acotando y
de igual forma, una cota inferior debe ser menor que todos los valores posibles del campo.
En este ejemplo, dado que los DNI son cifras de 8 dígitos, el valor 999999999 funciona
correctamente como cota superior para el número de DNI. Análogamente el valor 11 podría ser
una cota superior para un conjunto de notas (valores entre 0 y 10) y el valor –1 una cota inferior
para el mismo conjunto.
Para trabajar correctamente, usaremos un #define para establecer el valor de la COTA, de esta
forma ganamos en claridad en la resolución y facilitamos una eventual modificación del valor para
la cota. En este caso, debemo escribir antes de las declaraciones ya realizadas:
#define COTA 999999999
Ahora ya podemos escribir el procedimiento de lectura, al que además del archivo y el registro,
pasaremos la COTA para asignar al campo clave cuando se detecte el fin de archivo.
Este procedimiento lo usaremos para leer ambos archivos de entrada, ya que tienen registros del
mismo tipo, invocándolo en cada caso con los parámetros correspondientes.
void Leer_aInsc (FILE * &arch, ty_rInsc & reg, int iValorcota)
Presentamos el diagrama que expresa la estrategia de solución analizada anteriormente.

Abrir aSede (aInscBA, “rb”)
Abrir aSede (aInscLP, “rb”)
Abrir aInscU (aInscU, “wb”)
Leer aInsc (aInscBA, rInscBA, COTA)
Leer aInsc (aInscLP, rInscLP, COTA)
(rInscBA.DNI != COTA) || (rInscLP.DNI != COTA)

rInscBA.DNI < rInscLP.DNI
True False
Los dos registros
rInscBA.DNI > rInscLP.DNI
True False
tienen el mismo
Grabar (aInscU, rInscBA) DNI
Grabar (aInscU, Grabar (aInscU,
rInscBA) rInscBA)
Leer aInsc (aInscBA,

rInscBA, COTA)
Leer aInsc (aInscBA, rInscBA,
COTA) Leer aInsc (aInscBA, Leer aInsc (aInscLP,
rInscBA, COTA) rInscLP, COTA)
CerraraSede (aInscBA)
CerraraSede (aInscLP)
CerraraSede (aInscU)
Observe que nunca se llamará al procedimiento de lectura para un archivo que alcanzó el fin de
archivo. ¿Por qué? Justifique
Piense ANTES de continuar leyendo…
Efectivamente cuando un archivo finaliza, el procedimiento de lectura asigna el valor COTA a la
clave del registro. Por lo tanto las claves (DNI en este caso) de los registros del otro archivo
siempre resultarán menores; por lo tanto se grabarán en el archivo de salida y se leerá sobre este
archivo. Así hasta que este archivo también alcance el fin, en este caso también tendrá COTA en
su campo clave y se saldrá del ciclo.
Actividades:
• Realizar el seguimiento del diagrama anterior con los siguientes datos de prueba, analizar
como se va avanzando en las lecturas de los archivos de entrada y se genera el archivo
resultante.
Por simplicidad sólo incluimos los campos DNI y ApyN en los registros del lote de prueba.
archivo aInscBA archivo aInscLP

DNI ApyN DNI ApyN
10123444 Nas, Claudio 10022033 Gral, Federico

13888777 Puig, Matías 10111222 Paez, Jorge
20922333 Lont, Mirta 14666777 Duck, Nicolás
21789789 Kop, Luis 20922333 Lont, Mirta
• Proponer otro lote de prueba, o modificar el anterior para que ambos archivos terminen
“simultáneamente” (sugerimos releer el desarrollo de la estrategia de solución).
• ¿Qué ocurre si uno de los 2 archivos de entrada está vacío, esto es, si en alguna de las
sedes no se registró ningún inscripto?
• Redactar el enunciado de un problema de apareo de dos archivos secuenciales.
• Pensar y plantear una estrategia de resolución, si en lugar de 2, se leen 3 archivos. Por

ejemplo se agrega una sede de inscripción en Tandil. ¿Y si fueran más? Generalizar para
más de 3 archivos de entrada.
Síntesis del Módulo I

En este módulo presentamos conceptos básicos sobre qué es un archivo, cómo esta formado, y
cuál es su uso más frecuente. También mencionamos las formas de organización de archivos, y
trabajamos con mayor grado de detalle con archivos de organización secuencial.
Revisamos las operaciones básicas para el manejo de archivos, asociándolas con las instrucciones
de lenguaje C++ para abrir, cerrar, leer y grabar archivos secuenciales.
Formalizamos y ejemplificamos la técnica de programación denominada corte de control, que
permite resolver determinadas situaciones en las cuales es necesario agrupar los registros
almacenados en un archivo ordenado, de acuerdo a la información almacenada en uno o más
campos.
Aprendimos el proceso de apareo de archivos, que permite obtener un archivo actualizado o

archivo resultante, a partir del procesamiento de 2 o más archivos ordenados por una misma clave.
Sintetizando podemos expresar que en todo proceso de apareo de 2 archivos secuenciales, A1 y

A2, se comparan las claves de 2 registros (1 de cada archivo de entrada, R1 y R2), y los
resultados pueden ser 3:
clave R1 < clave R2
la interpretación de esta relación y la
clave R1 == clave R2 consecuente acción a tomar
clave R1 > clave R2 dependen del problema a resolver.
Autoevaluación
Indique si es Verdadera o Falsa cada una de las siguientes afirmaciones
- Entendemos un archivo como una sucesión lógica de registros; los campos de un registro son la
unidad mínima de información del mismo, y se diferencian por el significado dado a cada uno,
pudiendo ser del mismo o distinto tipo (desde el punto de vista de la programación).

- En un archivo de organización secuencial la lectura se realiza desde el primer registro, pasando

por cada uno de los restantes en forma aleatoria, hasta leer la totalidad de los registros.
- Al momento de procesar los datos almacenados en los archivos, debemos leer y procesar un
registro por vez, de la misma forma que lo haríamos si los datos se ingresaran por teclado.
- Para aplicar la técnica de corte de control, los datos deben estar ordenados por el campo más
significativo de la estructura del registro.
- En un proceso de corte de control se debe utilizar el esquema de lectura adelantada para que con
la primera lectura se puedan inicializar las variables que guardan los datos anteriores.
- En un proceso de apareo, no es necesario que los archivos estén ordenados por el mismo
campo.

PII ModuloI Archivos v3

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

PII ModuloI Archivos v3

Caricato da

Copyright:

Formati disponibili

INSTITUTO DE TECNOLOGIA O.R.T.

Instituto incorporado a la enseñanza Oficial (A-763)

POGRAMACIÓN II Año 2008

Organización de Archivos .............................................................................................................................................................. 4

Archivos Secuenciales .................................................................................................................................................................... 4

Lectura y grabación de datos ........................................................................................................................................................ 5

Corte de Control .............................................................................................................................................................................. 11

Síntesis del Módulo I...................................................................................................................................................................... 22

Programación 2 / Módulo I Pág. 1

En el desarrollo de este módulo abordaremos:

Conceptos generales de archivos

Comprender la comunicación entre la memoria de la computadora y los dispositivos de

Aclaraciones previas al estudio

Programación 2 / Módulo I Pág. 2

¿Qué es un archivo? ¿Para qué uso un archivo?

¿Qué son los archivos?

Hablamos de grupo de datos estructurado. Generalmente cada componente de este grupo de

¿Para qué uso un archivo?

Encontramos a nuestro alrededor varios ejemplos de utilización de archivos: los archivos de

Este tipo de organización no permite la eliminación de registros ni la inserción en cualquier lugar,

Lectura y grabación de datos

Operaciones básicas con archivos

Abrir archivo para lectura

En el procedimiento de apertura de archivos, pasamos 4 parámetros:

ArchivoDatos es el puntero que va a ir moviéndose por el archivo. En el momento de la apertura,

La implementación de esta rutina en lenguaje C++ sería de la siguiente forma:

Y la llamada o invocación en el diagrama seria, por ejemplo:

Programación 2 / Módulo I Pág. 6

Abrir archivo para escritura

Determinar la condición de fin de archivo (EOF)

Programación 2 / Módulo I Pág. 7

En el procedimiento de lectura de archivos, pasamos 3 parámetros:

aDatos es el puntero al archivo a leer

La implementación de esta rutina en lenguaje C++ sería de la siguiente forma:

void LeerArchivoDatos (FILE * &aDatos, ty_reg &sRegDatos, bool &bFin)

En el procedimiento de escritura de archivos, pasamos sólo 2 parámetros:

aDatos es el puntero al archivo a leer

La implementación de esta rutina en lenguaje C++ sería de la siguiente forma:

void GrabarRegistroDatos (FILE * &aDatos, ty_reg sRegDatos)

void CerrarArchivoDatos (FILE * &aDatos)

Programación 2 / Módulo I Pág. 8

La implementación de esta rutina en lenguaje C++ sería de la siguiente forma:

void CerrarArchivoDatos (FILE * &aDatos)

Como cada lenguaje de programación maneja a su manera el EOF, vamos a generalizar la

A continuación veamos un ejemplo de lectura y escritura de archivos.

void LeerregistroNovedades (FILE * &Arch, ty_reg &registro, bool &bFin)

Programación 2 / Módulo I Pág. 9

El procedimiento será el siguiente:

AbrirArchivo (sUbicNov, “rb”, aNovedad, bPude)

AbrirArchivo (sUbicMae, “wb”, aMaestro, bPude)

AbrirArchivo (sUbicErr, “wb”, aErrores, bPude)

LeerRegistroNovedades (aNovedad, RegNov, bFinNov) Archivo de Salida

!bFinNov El formato del registro

LeerRegistroNovedades (aNovedad, RegNov, bFinNov)

Si observamos el diagrama, existen dos llamadas al procedimiento de lectura, la primera es la

AbrirN (“rb”, aNotas)

Abre para lectura en forma binaria el archivo aNotas.

Es importante recordar que en la implementación es necesario indicar también la ubicación del

En este contexto asumimos que siempre es posible abrir el archivo.

Programación 2 / Módulo I Pág. 10

Remontándonos a un ejercicio típico de Algoritmos y Estructura de Datos I, supongamos el

Confeccionar un programa que procese la información de las ventas de una distribuidora de

• Nro Factura (15 Caracteres)

El programa debe informar: