UCSE - 2022

Declarar una estructura (struct) con nombre Direccion con el siguiente formato:
-barrio
-calle
-nro
-piso
-dpto

Declarar una estructura (struct) con nombre Paciente para almacenar los siguientes datos:
-id (identificador numérico)
-apellido
-nombre
-obra social
-direccion Debe hacer referencia a la estructura “Direccion”, es una estructura anidada

Cargar la estructura con 2 pacientes, solicitando por pantalla la información respectiva de cada uno
Imprimir por pantalla la información de todos los registros cargados
Usar funciones/procedimientos para cargar y mostrar la información
 Es una serie de opciones que el usuario puede elegir para realizar
determinadas tareas
 Permite organizar las funciones que realiza el sistema cuando el mismo se
va haciendo grande
 Cada opción normalmente llama a una función o un procedimiento
 Pueden haber tantas opciones como funciones tenga el programa
 Contribuye a la modularidad del sistema
 Permiten que el programa sea fácil de usar por parte del usuario
 Pueden ser por consola de comandos (pantalla negra) o bien con una
interfaz de usuario (UI) definida
Partes que lo componen:

 Bucle DO-WHILE que presenta las opciones y procesa el ingreso por parte del usuario
 Dentro del DO-WHILE:

○ Presentación al usuario de las opciones

○ Solicitud de ingreso de opción por teclado

○ Switch o sentencias IF para ir comparando cada opción

○ Llamada a funciones o procedimientos correspondientes

○ Siempre debe existir una opción que nos permita SALIR del
programa
int main (){
struct articulos vecArticulos [44];
struct rubro vecRubro[19];
int opcion;
while ( opcion != 0){
cout << " ++++++++++++++ MENU DE OPCIONES ++++++++++++" << endl;
cout << " Opcion 1: Carga vector rubro ";
cout << " Opcion 2: Carga vector articulo ";
cout << " Opcion 3: Modificar vector articulo ";
cout << " Opcion 4: Impresion por codigo de rubro ";
cout << " Opcion 0. Salir " << endl;
cin >> opcion;
switch(opcion){
case 1:
cargaDatosRubro(vecRubro);
break;
case 2:
cargaDatosArticulos (vecArticulos,vecRubro);
break;
case 3:
modArt (vecArticulos, vecRubro);
break;
case 4:
impresion (vecArticulos);
break;
}
}
}
Al programa construido en el ejercicio 1 de la clase anterior, agregarle la
posibilidad de cargar 5 estudiantes y realizar lo siguiente, utilizando
funciones/procedimientos:
 Utilizar un menú de opciones para cada opción (ej. carga, impresión, etc.)
 Imprimir cantidad de estudiantes con edad menor a 20, cantidad de
estudiantes con edad mayor o igual que 20 y menor que 25, y estudiantes
con edad mayor que 25.
 Imprimir edad promedio de los estudiantes
 Imprimir todos los datos del primer estudiante encontrado que tenga la
mayor edad del grupo
 Imprimir todos los datos del primer estudiante encontrado que tenga la
menor edad del grupo
 Surgen de la necesidad de almacenar información y hacerla portable, es decir
transportable de un medio de almacenamiento a otro.
 Permiten almacenar información en la memoria secundaria o sea en disco.
 Se pueden acceder por diferentes programas según la necesidad.
 Son la forma en que el lenguaje C++ permite el acceso al disco para
almacenar información y leer información.
 Los archivos almacenan registros, donde un registro es un conjunto de datos
relacionados a algo en particular. Ej. Un libro dentro de una biblioteca, el
registro estaría compuesto por título, autor, editorial, año, etc.
 Los registros son las estructuras (struct) vistas.
 Tienen un nombre en particular para identificarlos
 Tienen una extensión para identificar su tipo
 Contienen información relacionada, por ej. registros
 Se realizan dos operaciones básicas: lectura y escritura
 Existen varios modos o formas de apertura de los mismos, según la operación
a realizar
 Se deben cerrar al finalizar su uso, así se almacene su información en disco y
se liberen recursos asociados a su manejo
 Se pueden establecer restricciones en el acceso y uso de los mismos como
forma de seguridad según el sistema operativo
Existen dos tipos de archivos:

 Según su contenido:
- Texto
- Binarios

 Según el tipo de acceso:

- Secuenciales
- Directos
Archivos de Texto
Almacenan información de texto plano, es decir que no tienen caracteres de control, sólo
caracteres imprimibles como letras, números y símbolos; por lo general del juego de
caracteres ASCII. Permitiendo así que sean intercambiados libremente y sean legibles por los
diferentes Sistemas Operativos existentes.

Archivos Binarios
Almacenan una secuencia de bytes o grupos de ocho dígitos binarios (bits). Pueden contener
información de cualquier tipo codificada en binario. Son interpretados por ciertos programas
dependiendo de su formato, por eso si se intenta abrirlos con un editor de texto la
información que se visualiza es ilegible/inentendible. Ejemplos: archivos de texto con
formato, imágenes, videos, archivos ejecutables, entre otros.
Archivos Secuenciales
La información se organiza en registros de manera secuencial.
Deben recorrerse para leer o almacenar la información, todo es en secuencia.
Normalmente, la escritura se hace al final del archivo.
Son rápidos para escribir y almacenar información, pero lentos para localizar un registro en
particular.

Archivos de Acceso Directo

También llamados aleatorios, los mismos no necesitan recorrerse secuencialmente para
poder utilizarse.
El acceso a un registro se realiza de forma directa por el número de línea o posición a leer.
Son muy rápidos para recuperar información.
Uso en C++

El uso de archivos en C++ parte del archivo de cabecera <fstream>, el cual define las clases:

 ifstream: (I -> In, Entrada) permite sólo operaciones de LECTURA en archivos

 ofstream: (O -> Out, Salida) permite sólo operaciones de ESCRITURA en archivos

 fstream: permite operaciones de LECTURA y ESCRITURA en archivos

Usando objetos de estas clases se podrá trabajar con archivos según las operaciones que se
deseen realizar
Uso en C++ - Apertura y cierre del archivo
La apertura se realiza mediante la función open(), luego se trabaja escribiendo o leyendo el
archivo y finalmente el cierre se realiza con la función close().
Al usar open() si el archivo no existe será creado, sino será abierto.

ofstream archivo; //Alternativa usando el constructor de ofstream

archivo.open("datos.txt"); ofstream archivo("datos.txt");

//Se trabaja con el archivo //Se trabaja con el archivo

archivo.close(); archivo.close();
Uso en C++ - Modos de Apertura

Cuando se abre un archivo, se debe especificar siempre el modo o forma de

apertura para que según esto se realice una u otra operación con el mismo y el
manejo por parte del programa sea correcto.
Si no se especifica un modo de apertura, por defecto, el contenido del archivo
siempre será reemplazado.
Puede que se necesite agregar datos a los ya existentes dentro del archivo o bien
sólo deba leerse el mismo y no realizarse ninguna otra operación es, por tanto,
necesario indicar un modo o forma de apertura del archivo.
Uso en C++ - Modos de Apertura
 ios::app Operaciones de añadir o agregar, siempre al final del archivo.
 ios::ate Coloca el apuntador del archivo al final del mismo y puede moverse según se necesite.
 ios::in Operaciones de lectura. Esta es la opción por defecto para objetos de la clase ifstream.
 ios::out Operaciones de escritura. Esta es la opción por defecto para objetos de la clase
ofstream.
 ios::nocreate Si el archivo no existe se suspende la operación.
 ios::noreplace Crea un archivo, si existe uno con el mismo nombre la operación se suspende.
 ios::trunc Crea un archivo, si existe uno con el mismo nombre lo borra.
 ios::binary Operaciones binarias.
Uso en C++ - Escritura en el archivo
Se abre el archivo con la función open(), luego se indica el modo de apertura del mismo con
ios::modo (donde modo es alguno de los modos de apertura permitidos), se escribe dentro
del archivo y finalmente el cierre se realiza con la función close().

ofstream archivo;
archivo.open("datos.txt“, ios::out);

//Se trabaja con el archivo

archivo.close();
Uso en C++ - Escritura en el archivo
Luego de abrir el archivo, es recomendable verificar el resultado de esta apertura. Para ello se
realiza la validación de las “banderas de estado” sobre el manejo del archivo.
Existen varias banderas tales como „bad()‟, „fail()‟, „eof()‟ y „good()‟, se utilizará „fail()‟.

//Se abre el archivo

if (archivo.fail()){
cout << "No se puede abrir el archivo" << endl;
exit(1);
}
//Se trabaja con el archivo
//Se cierra el archivo
Uso en C++ - Lectura en el archivo
Se abre el archivo con la función open(), luego se indica el modo de apertura del mismo con
ios::modo (donde modo es alguno de los modos de apertura permitidos), se recorre de
principio a fin el archivo (controlando bandera „eof()‟) y finalmente el cierre se realiza con la
función close().

ifstream archivo; string lineaArchivo;

archivo.open("datos.txt“, ios::in);
while (!archivo.eof()){
if (archivo.fail()){ getline(archivo, lineaArchivo);
cout << “Error al abrir" << endl; cout << lineaArchivo << endl;
exit(1); }
}
archivo.close();
Uso en C++ - Lectura en el archivo
Para realizar la lectura de cada línea del archivo se utiliza la función getline(origen, destino)
Donde origen es la fuente de donde se leen los datos y destino la variable que almacenará el
valor leído. Esta función se usa también para capturar la entrada por teclado del usuario ya
que lee una línea completa y evita que se corte al detectar un espacio como ocurre con cin()

string lineaArchivo; //Una variable tipo string que contendrá la línea leída del archivo

while (!archivo.eof()){ //Mientras NO sea el fin del archivo

getline(archivo, lineaArchivo); //Se lee la línea completa y se guarda en la variable tipo string

cout << lineaArchivo << endl; //Se imprime la variable que contiene la línea leída
}
Uso en C++ - Continuar escritura al final del archivo
Para continuar escribiendo en el archivo en la última posición al final del mismo,
simplemente se siguen los pasos para abrir un archivo para escritura, con la diferencia que
ahora se cambia el modo de apertura por ios::app. „app‟ es por append o agregar, en este
caso el C++ posicionará el puntero al final del archivo y permitirá que se siga escribiendo
desde ahí en adelante.
ofstream archivo;
archivo.open("datos.txt“, ios::app);

//Se trabaja con el archivo

archivo.close();
Uso en C++ - Búsqueda en el archivo
Para realizar la búsqueda, de forma secuencial, simplemente se siguen los pasos para abrir
un archivo para lectura, luego, mientras no se llegue al final del archivo, se evalúa una
condición comparando la fila leída contra el valor a buscar mediante la ayuda de la función
find(). Una vez encontrada una coincidencia o bien llegado el fin del archivo, se detiene la
búsqueda.
string lineaArchivo;
int posString;

while (!archivo.eof()){
getline(archivo, lineaArchivo);

//Verificamos con find() si 'textoBuscar' esta o no dentro de 'lineaArchivo' y extraemos su posicion

//En caso de que find() no encuentre el valor buscado, su valor será el dado por 'string::npos'
posString = lineaArchivo.find(textoBuscar);

//Si el texto buscado fue encontrado (su posición 'posString' es distinta de 'string::npos')
if(posString != string::npos) //'string::npos' es una ctte. que significa 'sin posicion'
{
cout <<"Resultado encontrado: " << endl;
cout << lineaArchivo << endl;

break; //Para salir del while

}
}
Aclaración sobre uso de cin y getline()
En ocasiones, al usar getline() en combinación con cin, puede ocurrir que al realizar la ejecución de getline()
ocurra un salto de línea inesperado y se lea un carácter invisible o ocasionando que no se tome la entrada
por teclado y el programa se siga ejecutando.

Esto se debe a que cin a veces puede guardar en buffer el llamado retorno de carro “\n” o algún otro
carácter invisible no deseado y al ejecutarse el getline() el programa lo lee y lo toma como entrada.

Para evitarlo, cuando se usen en el mismo programa cin y getline(), se deberá, ANTES DEL GETLINE utilizar
la llamada a la función sync() para limpiar el buffer de la siguiente manera: cin.sync()

Ej.
cin >> unaVar; //Se lee con cin lo ingresado por teclado y se asigna a una variable
cin.sync(); //Se limpia el buffer de cin
getline(cin, otraVar); //Se lee con getline() lo ingresado por teclado sin problemas
Ejercicio 1
Utilizando funciones y menú de opciones:
-Crear un archivo secuencial de texto llamado “ejercicio1" con la extension ".txt"

-Opciones:
Carga de datos: solicitar al usuario que ingrese 3 libros, indicando solamente el nombre del
mismo. Guardar en el archivo.
Imprimir todo: se deberá imprimir por pantalla todo el contenido del archivo.
Buscar: se deberá poder buscar dentro del archivo un libro, previa solicitud al usuario, y
luego imprimir el primer registro encontrado.
UCSE - 2022
Uso en C++ - Modificación en el archivo
Para realizar la modificación, primero debe solicitarse el dato a buscar, luego se realiza la
búsqueda propiamente dicha dentro del archivo de manera secuencial. Si no se encuentra la
información buscada, se informa al usuario; caso contrario se solicita al usuario que indique
cuál será el nuevo valor para sobrescribir el previo. Finalmente se cierra el archivo.
Uso en C++ - Modificación en el archivo
Normalmente la secuencia de pasos anterior sería la ideal pero podría ocurrir que se encuentren
espacios de más entre los datos del archivo o alguna tabulación, entre otros problemas. En estos
casos, debido a que se está trabajando con archivos de texto plano, lo adecuado es abrir el archivo
original y copiar el contenido en un nuevo archivo a medida que se realizan las modificaciones.
La secuencia de pasos es:

 Abrir archivo original (a modificar) y abrir archivo nuevo (contendrá los datos previos y los modificados).
 Leer secuencialmente el archivo original buscando el dato a modificar. Mientras no se lo encuentre entonces se
copia y escribe la información en el archivo nuevo.
 Cuando se encuentre el dato a modificar en el archivo original, se modifica y se lo guarda en el archivo nuevo;
luego se continúa copiando y escribiendo en el archivo nuevo hasta finalizar.
 Finalizada la lectura del archivo original y copiada toda la información, se cierran ambos archivos, se elimina el
archivo original y se renombra el archivo nuevo con el nombre que tenía el archivo original. Quedando así un
único archivo.
Ejercicio 2
Utilizando funciones y menú de opciones:
-Crear un archivo secuencial de texto llamado "ejercicio1" con la extensión ".txt"
-Opciones:
Carga de datos: solicitar al usuario que ingrese 6 nombre y apellido. Guardar en el archivo
línea a línea.
Imprimir todo: se deberá imprimir por pantalla todo el contenido del archivo.
Buscar: se deberá poder buscar dentro del archivo un apellido en particular, previa solicitud
al usuario, y luego imprimir el primer registro encontrado.
Modificar: se deberá poder buscar un apellido en el archivo y luego modificarlo solicitando al
usuario que ingrese el nuevo valor para el mismo.
Uso en C++ - Estructuras (struct) – Forma 1 (separado por espacios)

 Es posible combinar las estructuras con los archivos.

 Se puede a partir de una estructura en particular, escribir en un archivo.
 Se puede a partir de un archivo, guardar los datos en una estructura e
imprimirlos o hacer alguna otra acción con los mismos.
Uso en C++ - Estructuras (struct) – Forma 2 (separado por comas)
Para evitar problemas cuando se guardan cadenas de texto con espacios, por
ejemplo un nombre completo, la alternativa ideal al momento de escribir una
estructura en un archivo es:
 Guardar cada atributo o campo de la misma separado por comas o algún otro
carácter cualquiera.
Ej. 1010,Mesa verde,1450
 Cada fila del archivo de texto será un registro que se corresponde a una
estructura.
Ej. 1010,Mesa verde,14500
1011,Silla blanca,1200
Uso en C++ - Estructuras (struct) – Forma 2 (separado por comas)
Al momento de leer cada fila del archivo y transformarla en un registro de una estructura
(struct), se puede utilizar stringstream, el cuál es básicamente un búfer en memoria que
simula comportarse como un archivo, permitiendo la lectura y manipulación. Todas las
operaciones se efectúan en memoria. stream es una interfaz de entrada/salida para
manipulación de datos.

string lineaArchivo;
getline(archivoOrigen, lineaArchivo); //Lee una línea del archivo y lo guarda en una variable string
stringstream stream(lineaArchivo); //Guarda el string con la línea leída en el stream para su manipulación

getline(stream, structEstudiante.nombre, ','); //Se lee la línea hasta el delimitador de fin de línea (“,” en este
caso)
//Guarda el dato leído en el campo indicado de la estructura
Ejercicio 3
Utilizando funciones/procedimientos, estructuras, archivos y menú de opciones:
-Crear un archivo secuencial de texto llamado "ejercicio1" con la extensión ".txt"
-Opciones:
Carga de datos: solicitar al usuario que ingrese 4 personas con los siguientes datos: dni,
nombre y apellido, edad, salario. Guardar en el archivo línea a línea separado por comas o
punto y coma (según se prefiera).
Imprimir todo: imprimir por pantalla todo el contenido del archivo.
Imprimir estadísticas: imprimir por pantalla el mayor salario, el menor y el promedio.
Buscar: buscar dentro del archivo un dni en particular, previa solicitud al usuario, y luego
imprimir el primer registro encontrado.
Modificar: se deberá poder buscar un dni en el archivo y luego modificar el registro
solicitando al usuario un nuevo valor para el campo salario únicamente.