República Bolivariana de Venezuela

Ministerio del Poder Popular para la educación

Universidad Nacional Experimental

“Antonio José de Sucre”

Bachiller:

Deliagny Lopez V- 28.481.423

1. Definición de archivos
Un archivo es una secuencia de datos almacenados en un medio persistente
que están disponibles para ser utilizados por un programa. Todos los archivos
tienen un nombre y una ubicación dentro del sistema de archivos del sistema
operativo.

Los datos en un archivo siguen estando presentes después de que termina el

programa que lo ha creado. Un programa puede guardar sus datos en
archivos para usarlos en una ejecución futura e incluso puede leer datos
desde archivos creados por otros programas.

Un programa no puede manipular los datos de un archivo directamente. Para

usar un archivo, un programa siempre abrir el archivo y asignarlo a una
variable, que llamaremos el archivo lógico. Todas las operaciones sobre un
archivo se realizan a través del archivo lógico.

2. Importancia.
Los archivos son importantes en programación porque permiten:
• Almacenamiento de datos: Los archivos permiten a los programas guardar
y recuperar datos de manera efectiva. Por ejemplo, un programa puede
guardar información de usuarios en un archivo para que pueda acceder a ella
más tarde.
• Comunicación entre programas: Los archivos son una forma común de
intercambiar datos entre programas.
• Persistencia de datos: Los archivos permiten a los programas almacenar
datos de forma persistente. Esto significa que los datos persisten después de
que el programa se cierra y se pueden recuperar
• Manejo de errores: Los archivos pueden ser útiles en el manejo de errores.
Por ejemplo, si un programa falla durante la ejecución, puede guardar
información sobre el error en un archivo para que el usuario pueda enviarlo al
equipo de soporte para su análisis.
3. Tipos de archivos
• Archivos de texto: son archivos normales que contienen información
almacenada en formato ASCII y que el usuario puede leer. Puede visualizar
e imprimir dichos archivos. Las líneas de un archivo de texto no deben
contener caracteres NUL y ninguna puede exceder de {LINE_MAX} bytes de
longitud, incluido el carácter de nueva línea.
• Los archivos binarios: son archivos normales que contienen información
que el sistema puede leer. Los archivos binarios podrían ser archivos
ejecutables que indicaran al sistema que ha de realizar un trabajo. Los
mandatos y los programas se almacenan en archivos binarios ejecutables.
Los programas de compilación especial convierten texto ASCII en código
binario.

4. Operaciones Básicas
-Apertura de un archivo: Para abrir un archivo, se debe especificar su
nombre y tipo. Luego, se utiliza la función "ifstream" para abrir el archivo y leer
la información almacenada en él.
Ejemplo:
#include <iostream>
#include <fstream>
using namespace std;

int main() {
ifstream archivo("ejemplo.txt");
string linea;
while(getline(archivo, linea)) {
cout << linea << endl;
}
archivo.close();
return 0;
}
-Cierre para cerrar un archivo en C++, se utiliza la función close(). Por
ejemplo, para cerrar el archivo de entrada del ejemplo anterior, se puede usar
el siguiente código: archivoEntrada.close() ejemplo:
#include <iostream>
#include <fstream>
using namespace std;

int main() {
fstream archivo("ejemplo.txt", ios::in | ios::out);
string linea;
getline(archivo, linea);
cout << linea << endl;
archivo.seekg(0, ios::end);
archivo << "Otra línea de texto" << endl;
archivo.close();
return 0;
}
En este ejemplo se abre el archivo "ejemplo.txt" en modo de lectura y escritura
utilizando la función "fstream". Se lee la primera línea del archivo utilizando la
función "getline()" y se imprime en la pantalla. Luego, se ubica la posición del
archivo al final utilizando la función "seekg()" y se escribe la cadena de texto
"Otra línea de texto" en una nueva línea. Finalmente, se cierra el archivo
utilizando la función "close()".

5. Archivos Secuenciales: son aquellos en los que la información se

almacena en una secuencia, es decir, cada registro se escribe uno detrás del
otro en el archivo. Estos archivos se utilizan comúnmente para almacenar
grandes cantidades de datos que no necesitan ser accedidos en un orden
específico.
-Creacion / Escritura: Escribir en un archivo: para escribir en un archivo en
C++, se utiliza la función << para escribir datos en el archivo. Por ejemplo:
#include <iostream>
#include <fstream>
using namespace std;

int main() {
ofstream archivo("ejemplo.txt", ios::out);
archivo << "Primera línea de texto" << endl;
archivo << "Segunda línea de texto" << endl;
archivo.close();
return 0;
}
En este ejemplo se crea un archivo llamado "ejemplo.txt" y se escriben dos
líneas de texto en él. La opción "ios::out" indica que el archivo se abrirá en
modo de escritura.
-Lectura se puede utilizar la clase ifstream (input file stream), que permite
abrir y leer archivos de texto. La sintaxis básica para leer un archivo
secuencial es la siguiente:
#include <iostream>
#include <fstream>
using namespace std;
int main() {
ifstream archivo("datos.txt", ios::in);
string linea;
while(getline(archivo, linea)) {
cout << linea << endl;
}
archivo.close();
return 0;
}
En este ejemplo, se abre el archivo "datos.txt" en modo de lectura (ios::in)
utilizando la clase ifstream y se lee cada línea del archivo utilizando la función
getline. La función getline lee una línea completa del archivo y la almacena
en la variable "linea". Luego, se muestra la línea en la consola utilizando cout.
El ciclo while continúa hasta que se llega al final del archivo.
-Actualizacion (Borrado / Renombrado)
Una forma común de actualizar un archivo es mediante la operación de
renombrado, que consiste en crear un archivo temporal, copiar los datos del
archivo original en el archivo temporal, actualizar los datos necesarios en el
archivo temporal y, finalmente, renombrar el archivo temporal con el nombre
del archivo original.
Ejemplo:
#include <iostream>
#include <fstream>
using namespace std;

int main() {
ifstream archivo_entrada("datos.txt");
ofstream archivo_temporal("temp.txt");
string linea;
while(getline(archivo_entrada, linea)) {
// Aquí se pueden realizar las operaciones de actualización necesarias
archivo_temporal << linea << endl;
}
archivo_entrada.close();
archivo_temporal.close();
remove("datos.txt");
rename("temp.txt", "datos.txt");
return 0;
}
En este ejemplo, se abre el archivo "datos.txt" en modo de lectura utilizando
la clase ifstream y se crea un archivo temporal llamado "temp.txt" en modo de
escritura utilizando la clase ofstream. Luego, se lee cada línea del archivo
original utilizando la función getline y se realizan las operaciones de
actualización necesarias. En este caso, se copia cada línea en el archivo
temporal sin modificarla.
Después de que se han realizado las operaciones de actualización
necesarias, se cierran ambos archivos y se eliminan el archivo original
utilizando la función remove y se renombra el archivo temporal con el nombre
del archivo original utilizando la función rename.
Es importante tener en cuenta que, aunque la operación de renombrado es
útil para actualizar un archivo, también puede ser riesgosa si no se realiza
correctamente. Por ejemplo, si el programa se detiene mientras se están
realizando las operaciones de actualización, se pueden perder los datos del
archivo original. Por lo tanto, se recomienda hacer una copia de seguridad del
archivo original antes de realizar cualquier operación de actualización.

6. Archivos aleatorios: también conocidos como archivos indexados,

permiten acceder a los registros de forma aleatoria, es decir, sin tener que
leer y recorrer todo el archivo desde el principio. Para poder acceder de forma
aleatoria a los registros, es necesario crear un índice que asocie a cada
registro una clave que lo identifique de forma única.

-Creacion / Escritura: Se crea un archivo aleatorio indicando la estructura de

los registros y se escriben los registros en el archivo. Ejemplo:
#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;

struct Registro {
 int clave;
char nombre[30];
float salario;
};

int main() {
Registro reg;
fstream archivo("datos.dat", ios::binary | ios::out);
if (!archivo) {
cout << "Error al abrir el archivo" << endl;
return 1;
}
for (int i = 0; i < 3; i++) {
cout << "Ingrese la clave del registro: ";
cin >> reg.clave;
cin.ignore();
cout << "Ingrese el nombre del registro: ";
cin.getline(reg.nombre, 30);
cout << "Ingrese el salario del registro: ";
cin >> reg.salario;
archivo.write((char*)&reg, sizeof(reg));
}
archivo.close();
return 0;
}
Este programa crea un archivo llamado "datos.dat" y escribe tres registros de
tipo "Registro" en él. Se utiliza "ios::binary" para abrir el archivo en modo
binario y "ios::out" para abrirlo en modo escritura.
-Lectura: Se accede a un registro específico a partir de su clave.
Ejemplo:
#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;

struct Registro {
int clave;
char nombre[30];
float salario;
};

int main() {
Registro reg;
fstream archivo("datos.dat", ios::binary | ios::in);
if (!archivo) {
cout << "Error al abrir el archivo" << endl;
return 1;
}
cout << "Ingrese la clave del registro que desea leer: ";
int clave;
cin >> clave;
archivo.seekg((clave - 1) * sizeof(Registro));
archivo.read((char*)&reg, sizeof(Registro));
if (archivo.eof()) {
cout << "No se encontro el registro" << endl;
} else {
cout << "Clave: " << reg.clave << endl;
cout << "Nombre: " << reg.nombre << endl;
cout << "Salario: " << reg.salario << endl;
}
archivo.close();
return 0;
}
Este programa abre el archivo "datos.dat" en modo lectura y utiliza "seekg"
para buscar un registro específico según la clave ingresada por el usuario.
Luego, lee ese registro con "read" y lo muestra por pantalla.

Tanto en la creación/escritura como en la lectura de archivos aleatorios, es

importante tener en cuenta que se debe utilizar "ios::binary" y que se debe
acceder a los registros utilizando la función "seekg" o "seekp".

7. Realizar un programa donde se cree, lea, escriba y actualice (eliminar,

insertar o modificar algún registro seleccionado por el usuario) un
archivo secuencial, para ellos utilizar un menú de opciones. Usando
lenguaje c++
#include<iostream>
#include<fstream>
#include<windows.h>
#include<conio.h>

using namespace std;

int menu() {
int op;
system("cls");

cout << "----MENU DE OPCIONES-----\n";

cout << "1. Registrar persona\n";
cout << "2. Mostrar Listado de personas\n";
cout << "3. Buscar Persona\n";
cout << "4. Actualizar Persona\n";
cout << "5. Borrar Persona\n";
cout << "6. Salir\n";
cin >> op;
return op;
}

bool validar(string c) {
ifstream f("datos.txt",ios::in);
string ced,nom,ape;
f>>ced;
while(!f.eof()) {
if(c==ced) {
f.close();
return false;
}
f>>nom;
f>>ape;
f>>ced;
}
f.close();
return true;
}

void registrar(ofstream &f) {

system("cls");
string ced,nom,ape;
f.open("datos.txt",ios::out|ios::app);
cout << "CEDULA : ";
cin >> ced;
if(validar(ced)) {
cout << "NOMBRE : ";
cin >> nom;
 cout << "APELLIDO : ";
cin >> ape;
f << ced << " " << nom << " " << ape <<"\n";
cout <<"REGISTRADO EXITOSAMENTE...\n";
}
f.close();
getch();
}

void mostrar(ifstream &f) {

string ced,nom,ape;
system("cls");
f.open("datos.txt",ios::in);
f >> ced;
while(!f.eof()) {
cout << "\nCEDULA : " << ced << endl;
f >> nom;
cout << "NOMBRE : " << nom << endl;
f >> ape;
cout << "APELLIDO : " << ape << endl;
f >> ced;
}
f.close();
getch();
}

void buscar(ifstream &f) {

string ced,nom,ape,cedb;
system("cls");
bool esta=false;
f.open("datos.txt",ios::in);
cout << "Ingrese la Cedula de la persona a buscar : ";
cin >> cedb;
f >> ced;
while(!f.eof()) {
if(ced == cedb) {
cout << "CEDULA : " << ced << endl;
f >> nom;
cout << "NOMBRE : " << nom << endl;
f >> ape;
cout << "APELLIDO : " << ape << endl;
esta = true;
break;
}
f >> ced;
}
if(!esta)
cout << "Esta Persona no esta registrada\n";
getch();
}

void borrar(ifstream &f) {

system("cls");
string ced,nom,ape,ced2,nom2,ape2;
f.open("datos.txt",ios::in);
ofstream faux("temp.txt",ios::out);
if(f.is_open()) {
cout << "CEDULA: ";
cin >> ced2;
f >> ced;
while(!f.eof()) {
if (ced == ced2) {
 f >> nom;
f >> ape;
cout <<"REGISTRO ELIMINADO EXITOSAMENTE...\n";
getch();
} else {
faux << ced << " ";
f >> nom;
faux << nom << " ";
f >> ape;
faux << ape << "\n";
}
f >> ced;
}
f.close();
faux.close();
} else {
cout << "No se puede abrir el archivo...\n";
}
remove("datos.txt");
rename("temp.txt","datos.txt");
}

main() {
ofstream F;
ifstream Fl;
int opc;
do {
opc = menu();
switch(opc) {
case 1:
registrar(F);
 break;
case 2:
mostrar(Fl);
break;
case 3:
buscar(Fl);
break;
/*case 4:
actualizar();
break;*/
case 5:
borrar(Fl);
break;
}
} while(opc != 6);
}