Recuperación Al Instante de PROBLEMAS - Asd

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
using namespace std;
#define archivo "f:\\Alumnos.dat"
struct ALUMNO
{ int Cod;
char Nombre[30];
int Nota;
};
int main()
{system("cls");
FILE *F;
ALUMNO A;
F = fopen(archivo,"w");
if(F==NULL)
{cout<<" no existe el archivo "<<endl;
getche();
exit (0);
}
fclose(F);
cout<<"ARCHIVO VACIO CREADO CON EXITO !!!!!!!"<<endl;
getche();
}
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#define archivo "E:\\Alumnos.dat"
struct ALUMNO
{
int Cod;
char Nombre[30];
int Nota;
};
int main()
{system("cls");
FILE *F;
ALUMNO A;
char rpta;
int codigo;
// captura de campos de datos
// crea el bucle para ingresar varios registros
do
{system ("cls");
cout<<"Ingrese el codigo a registrar : ";

cin>>codigo;
F = fopen(archivo,"a+");
//Consistencia de exito de apertura del archivo

if (F == NULL)
{
printf("No se puede abrir el archivo\n");
getche();
exit(1);
}
fread(&A,sizeof(A),1,F);// Lee el "Registro", de tamano=sizeof(Registro) del archivo
"f"
while(!feof(F)) // Ciclo mientras no se encuentre el final del archivo

{
if(A.Cod==codigo)
{
cout << "\n\n\n\rRegistro duplicado !!!";
fclose(F);
getch();
exit (0);
}
fread(&A,sizeof(A),1,F);
}
cout<<"Ingrese datos "<<endl;
A.Cod=codigo;
cout<<"Nombre ---> ";
fflush(stdin);
gets(A.Nombre);
do
{
cout<<"Nota -----> ";
cin>>A.Nota;
}while(A.Nota<0 || A.Nota>20);
// grabando a disco
fwrite(&A, sizeof(A), 1, F);
fclose(F);
cout<<"Alumno Archivado\n\n";
cout<<"Desea Ingresar Otro registro (S/N)? ";

cin>>rpta;
}while(rpta == 'S' || rpta == 's');
system ("pause");
return 0;
}
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#define archivo "E:\\Alumnos.txt"
struct ALUMNO
{
int Cod;
char Nombre[30];
int Nota;
};
int main()
{system("cls");
FILE *F;
ALUMNO A;
char rpta;
int codigo;
do
{system ("cls");

cin>>codigo;

if (F == NULL)
{
getche();
exit(1);
}
fread(&A,sizeof(A),1,F);// Lee el "Registro", de tamano=sizeof(Registro) del archivo

"f"

{
if(A.Cod==codigo)
{
fclose(F);
getch();
exit (0);
}
}
A.Cod=codigo;
fflush(stdin);
gets(A.Nombre);
do
{
cout<<"Nota -----> ";
cin>>A.Nota;
}while(A.Nota<0 || A.Nota>20);
// grabando a disco
fwrite(&A, sizeof(A), 1, F);
fclose(F);

cin>>rpta;
system ("pause");
return 0;
}
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <iomanip>
struct ALUMNO
{
int Cod;
char Nombre[30];
int Nota;
};
int main()
{system("cls");
FILE *F;
ALUMNO A;
F = fopen(archivo,"r+");

if (F == NULL)
{
getch();
exit(1);
}
cout<<"====================================================\n";
cout<<setw(10)<<"Codigo"<<setw(20)<<"Nombre"<<setw(10)<<"Nota\n";
cout<<"------------------------------------------------------\n";
// aqui siempre debe empezar el ciclo de lectura

// y fread() regresa siempre cuantas estructuras leyo
fread(&A, sizeof(A), 1, F);
while(!feof(F))
{ // desplegando estructuras
cout<<setw(10)<<A.Cod<<setw(20)<<A.Nombre<<setw(10)<<A.Nota<<endl;
cout<<"\n";
} // aqui termina while
// no olvidar cerrar archivo y siempre fuera de while
getche();
fclose(F);
printf("\n\n");
system ("pause");
return 0;
}
#include <iostream> #include <stdlib.h> #include <stdio.h> #include <conio.h>
#include <string.h> #include <iomanip> using namespace std;
#define archivo "E:\\Alumnos.dat"// Busqueda por Rango - NOTA
struct ALUMNO{
int Cod;
char Nombre[30];
int Nota;
};
int main()
{system("cls");
FILE *F;
ALUMNO A;
int Nota,encontrado,rep=1;
do
{
// cargando clave a buscar
cout<<"Nota >= --> ";
cin>>Nota;
//abriendo, leyendo,cargando estructura
if (F == NULL)
{
printf("No se encontro Archivo, No se puede abrir el archivo\n");
getche();
exit(1);
}
cout<<"=================================================\n";
cout<<"-------------------------------------------------\n";
// y fread() regresa siempre cuantas estructuras leyo
encontrado = 0;
while(!feof(F))
{ // desplegando Registro Buscado
if(A.Nota >= Nota)
{encontrado = 1;
cout<<"\n";
}
if (encontrado == 0)
cout<<"Ninguno Cumple con esta Condicion "<<endl;
system ("pause");
cout<<"Desea realizar otra busqueda si=1 no = 0)"<<endl;

cin>>rep;
}while (rep == 1);
system("cls");
cout<<"Fin Busqueda "<<endl;
system ("pause");
fclose(F);
}
#include <iostream> #include <stdlib.h> #include <stdio.h> #include <conio.h> #include
<string.h>#include <iomanip> using namespace std;
#define archivo "E:\\Alumnos.dat" #define archivo1 "E:\\temporal.dat"
// Elimina Registro
struct ALUMNO
{int Cod; char Nombre[30]; int Nota; };
int main()
{
system("cls");
FILE *F;
FILE *G;
ALUMNO A;
char op;
int encontrado=0, Codigo;
cout<<"Ingrese Codigo a Eliminar ---> ";

cin>>Codigo;
if (F == NULL)
{
cout<<"No se puede abrir el archivo\n";
getche();
exit(1);
}
G = fopen(archivo1,"a+");
if (G == NULL)
{
getche();
exit(1);
}
cout<<"=================================================\n";
cout<<"-------------------------------------------------\n";
while(!feof(F))
{ // Registro Buscado
if(Codigo != A.Cod)
fwrite(&A, sizeof(A), 1, G);
else
encontrado =1;
}
fclose(F);
fclose(G);
//Recordar que los nombres Directorios/carpetas y Archivos de datos no
// pueden tener mas de 8 caracteres
remove(archivo); // Elimina
rename(archivo1, archivo); //Cambia de nombre
if(encontrado == 0)
printf("No existe ese CODIGO ...\n\n");
else
printf("Registro Eliminado\n\n"); getche();system ("pause");
return 0;}
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <iomanip>
#define archivo1 "E:\\temporal.dat"
// Modifica campos
struct ALUMNO
{
int Cod;
char Nombre[30];
int Nota;
};
int main()
{int op,op1;
system("cls");
FILE *F;
FILE *G;
ALUMNO A;
cout<<"Codigo a Actualizar ---> ";
cin>>Codigo;
if (F == NULL)
{
system ("pause");
exit(1);
}
if (G == NULL)
{
exit(1);
system ("pause");
}
cout<<"======================================================\n";
cout<<"-------------------------------------------------------\n";
while(!feof(F))
if(Codigo == A.Cod)
{ do
{
cout<<"ACTUALIZAR CAMPOS "<<endl;
cout<<" 1: Nombres "<<endl;
cout<<" 2: Nota "<<endl;
cout<<"Ingrese que Desea Modificar "<<endl;
cin>>op;
switch(op)
{case 1: cout<<"Nuevo Nombre ---> ";
fflush(stdin);
gets (A.Nombre); break;
case 2: cout<<"Nueva Nota -----> ";
cin>>A.Nota; break;
}
cout<<"Desea actualizar otro campo ? Si [1] No [0] ";

cin>>op1;
}while(op1!=0);
encontrado = 1;
}
else
}
fclose(F);
fclose(G);
rename(archivo1, archivo); //renombre
//avisando
if(encontrado == 0)
printf("No existe el CODIGO ...\n\n");
else
printf("Registro Actualizado\n\n");
cout<< " Alumno actualizado con exito "<<endl;
getche();system ("pause");
}
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <iomanip>
#define archivo1 "E:\\temporal.dat"
struct ALUMNO
{
int Cod;
char Nombre[30];
int Nota;
};
void CrearData();
void MostrarData();
void Buscarxcodigo();
void Buscarxnombre();
void BuscarFiltroData();
void EliminarData();
void ModificarData();
int menu();
int main()
{
int op;
FILE *F;
ALUMNO A;
do
{system("cls");
op=menu();
switch (op)
{
case 1: CrearData();
break;
case 2: system("cls");
MostrarData();
getche();
break;
case 3: Buscarxcodigo();
break;
case 4: Buscarxnombre();
break;
case 5: BuscarFiltroData();
break;
case 6: EliminarData();
break;
case 7:
ModificarData();
break;
}
} while (op!=8);
system("cls");
cout<<"FIN PROCESO HASTA PRONTO !!!!!!!"<<endl;
getche();
return (0);
}
//-------------------------------------------------
int menu()
{int op;
do {system("cls");
cout<<"\t\t\tREGISTRO DE ALUMNOS\n\n";
cout<<"\t\t1 Crear \n";
cout<<"\t\t2 Mostrar \n";
cout<<"\t\t3 Buscar por codigo \n";
cout<<"\t\t4 Buscar por Nombre \n";
cout<<"\t\t5 Buscar con filtro \n";
cout<<"\t\t6 Eliminar \n";
cout<<"\t\t7 Modificar \n";
cout<<"\t\t8 Terminar \n";
cout<<"Ingrese su opcion ---> ";
cin>>op;
}
while (op<1 || op>8);
return op;
}
//-----------------------------------------------
void CrearData()
{system("cls");
FILE *F;
ALUMNO A;
char rpta;
int codigo;
do
{system ("cls");
cin>>codigo;
if (F == NULL)
{
getche();
exit(1);
}
fread(&A,sizeof(A),1,F);// Lee el "Registro", de tamano=sizeof(Registro)

del archivo "f"

{
if(A.Cod==codigo)
{
fclose(F);
getch();
return;
}
}

A.Cod=codigo;

fflush(stdin);
gets(A.Nombre);
do
{cout<<"Nota -----> ";
cin>>A.Nota;
}while(A.Nota <0 || A.Nota >20);
fwrite(&A, sizeof(A), 1, F); // grabando a disco

cin>>rpta;
fclose(F);

//avisando usuario
system ("pause");
system ("pause");
}
//-------------------------------------------------------------
void MostrarData()
{system("cls");
FILE *F;
ALUMNO A;
if (F == NULL)
{
getche();
exit(1);
}
cout<<"====================================================\n";
cout<<"------------------------------------------------------\n";
while(!feof(F))
cout<<"\n";
}; // aqui termina while
system ("pause");
fclose(F);
printf("\n\n");
system ("pause");
}
//--------------------------------------------------------------
void Buscarxcodigo()
{system("cls");
FILE *F;
ALUMNO A;
int Codigo,encontrado,rep=1;
do
{
cout<<"Codigo a buscar ---> ";
cin>>Codigo;
if (F == NULL)
{
getche();
exit(1);
}
cout<<"=================================================\n";
cout<<"-------------------------------------------------\n";
encontrado = 0;
while(!feof(F))
if(A.Cod == Codigo)
{encontrado = 1;
cout<<"\n";
}
cout<<"El alumno no esta registrado"<<endl;
system ("pause");
cout<<"Desea relizar otra busqueda si=1 no = 0)"<<endl;

cin>>rep;
}while (rep == 1);
system("cls");
system ("pause");
fclose(F);
}
//-----------------------------------------------------------------
void Buscarxnombre()
{system("cls");
FILE *F;
ALUMNO A;
char nom[30];
int encontrado,rep=1;
do
{
cin.ignore();
cout<<"Nomre a buscar ---> ";

cin.getline(nom,30);
if (F == NULL)
{
getche();
exit(1);
}
cout<<"=================================================\n";
cout<<"-------------------------------------------------\n";
encontrado = 0;
while(!feof(F))
if(strcmp(A.Nombre,nom)==0)
{encontrado = 1;
cout<<"\n";
}
cout<<"El alumno no esta registrado"<<endl;
system ("pause");
cout<<"Desea relizar otra busqueda si=1 no = 0)"<<endl;

cin>>rep;
}while (rep == 1);
system("cls");
system ("pause");
fclose(F);
}
//-----------------------------------------------------------------
void BuscarFiltroData()
{system("cls");
FILE *F;
ALUMNO A;
int Nota,encontrado,rep=1;
do
{
cout<<"Nota >= --> ";
cin>>Nota;
if (F == NULL)
{
getche();
exit(1);
}
cout<<"=================================================\n";
cout<<"-------------------------------------------------\n";
encontrado = 0;
while(!feof(F))
if(A.Nota >= Nota)
{encontrado = 1;
cout<<"\n";
}
cout<<"Ninguno Cumple con esta Condicion "<<endl;
system ("pause");
cout<<"Desea realizar otra busqueda si=1 no = 0)"<<endl;

cin>>rep;
}while (rep == 1);
system("cls");
system ("pause");
fclose(F);
}
//------------------------------------------------------------
void EliminarData()
{system("cls");
FILE *F;
FILE *G;
ALUMNO A;
char op;
cout<<"Ingrese Codigo a Eliminar ---> ";

cin>>Codigo;
if (F == NULL)
{ cout<<"No se puede abrir el archivo\n";
getche();
exit(1);}
if (G == NULL)
{ cout<<"No se puede abrir el archivo\n";
getche();
exit(1);
}
cout<<"=================================================\n";
cout<<"-------------------------------------------------\n";
while(!feof(F))
if(Codigo != A.Cod)
{
}
else
encontrado =1;
}
fclose(F);
fclose(G);
// pueden tener mas de 8 caracteres
rename(archivo1, archivo); //Cambia de nombre
if(encontrado == 0)
printf("No existe ese CODIGO ...\n\n");
else
printf("Registro Eliminado\n\n");
getche();system ("pause");
}
//----------------------------------------------------------------
void ModificarData()
{int resp;
system("cls");
FILE *F;
FILE *G;
ALUMNO A;
int Hallado=0, Codigo,op;
cout<<"Codigo a Editar ---> ";
cin>>Codigo;
if (F == NULL)
{
getche();
exit(1);
}
if (G == NULL)
{
exit(1);
}
printf("========================================\n");
printf("Codigo\t\tNombre\t\tNota\n");
printf("----------------------------------------\n");
while(!feof(F))
if(A.Cod == Codigo)
{ for(;;)
{system("cls");
cout<<"ACTUALIZAR CAMPOS "<<endl;
cout<<" 1: Nombres "<<endl;
cout<<" 2: Nota "<<endl;
cout<<"Ingrese que Desea Modificar "<<endl;
cin>>op;
switch(op)
{case 1: cout<<"Nuevo Nombre ---> ";
fflush(stdin);
gets (A.Nombre); break;
case 2: cout<<"Nueva Nota -----> ";
cin>>A.Nota; break;
}
Hallado = 1;
cout<<"Desea modificar otro campo 1/0 "<<endl;

cin>>resp;
if(resp==0)break;
}
cout<<"Fin de modificacion"<<endl;
getche();
}
else

fclose(F);
fclose(G);
//Removiendo y eliminando
// pueden tener mas de 8.3 caracteres
remove(archivo);
rename(archivo1,archivo);
//avisando
if (Hallado == 0)
printf("No existe el CODIGO ...\n\n");
else
printf("\nRegistro Actualizado\n");
system("pause");
}
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#define dim 20
struct personal
{
int Cod;
char Nombre[30];
char sexo;
int edad;
};
int main()
{
FILE *F;
personal reg;
char rpta;
int codigo;
do
{system ("cls");
cout<<"Ingrese datos en la estructura "<<endl;
cout<<"Codigo ---> ";
cin>>codigo;
// abre el archivo datos.txt
F = fopen("E:\\datos.txt","a+");

if (F == NULL)
{
system("pause");
exit(1);
}
fread(&reg,sizeof(reg),1,F);
// Lee el "Registro", de tamano=sizeof(Registro) del archivo "f"
{
if(reg.Cod==codigo)
{
fclose(F);
getch();
exit(1);
}
}
cout<<"Nombre ---> ";//Evita que salte

gets(reg.Nombre);
fflush(stdin);
cout<<"Sexo [M/F] -----> ";

cin>>reg.sexo;
cout<<"Edad -----> ";

cin>>reg.edad;
reg.Cod=codigo;// Graba los datos en archivo
fwrite(&reg, sizeof(reg), 1, F);
fclose(F);

cin>>rpta;
} while(rpta == 'S' || rpta == 's');
//cierra el archivo// fclose(F);
system ("pause");
return 0;
}
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <iomanip>
#define dim 20
struct personal
{
int Cod;
char Nombre[30];
char sexo;
int edad;
};
int main()
{system("cls");
FILE *F;
personal reg;
char rpta;
F = fopen("E:\\datos.txt","r");
if (F == NULL)
{
getche();
exit(1);
}
system ("cls");
cout<<"===================================================================\n";
cout<<setw(10)<<"Codigo"<<setw(20)<<"Nombre"<<setw(10)<<"Sexo"<<setw(10)<<"Edad\n";
cout<<"-----------------------------------------------------------------------\n";
fread(&reg, sizeof(reg), 1, F);
//crea el bucle mientras no sea el final del archivo
while(!feof(F))
cout<<setw(10)<<reg.Cod<<setw(20)<<reg.Nombre<<setw(10)<<reg.sexo<<setw(10)<<reg.edad<<end
l;
cout<<"\n";
} // aqui termina while// no olvidar cerrar archivo y siempre fuera de while
system ("pause");
fclose(F);
printf("\n\n");
getche();
system ("pause");
return 0;
}
#include <stdlib.h>
#include <iostream>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <iomanip>
#define dim 20
struct personal
{
int Cod;
char Nombre[30];
char sexo;
int edad;
};
int main()
{system("cls");
FILE *F;
personal reg,regtemporal,registro[dim];
int i,n,c=0,j;
F = fopen("E:\\datos.txt","r");
if (F == NULL)
{
getche();
exit(1);
}

fread(&reg, sizeof(reg), 1, F);
//crea el bucle mientras no sea el final del archivo
while(!feof(F))
{ // guarda el registro leido en el arrays de estructuras
registro[c]=reg;
c=c+1;
// lee el siguiente registro del archivo
fclose(F);
// ordena los registros utilizando el array de estructuras
for(i=0;i<c;i++ )
for(j=i+1;j<c;j++)
if (strcmp(registro[i].Nombre,registro[j].Nombre)>0)
{regtemporal=registro[i];
registro[i]=registro[j];
registro[j]=regtemporal;
}
//Imprime los registros ordenados
system ("cls");
cout<<" LISTADO DEL PERSONAL "<<endl<<endl<<endl;
cout<<"===================================================================\n";
cout<<"-----------------------------------------------------------------------\n";
for (i=0;i<c;i++)
cout<<setw(10)<<registro[i].Cod<<setw(20)<<registro[i].Nombre<<setw(10)<<registro[i].sexo<
<setw(10)<<registro[i].edad<<endl;
getche();
system ("pause");
return 0;
}
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <iomanip>
#include <iostream>
#define dim 20
struct personal
{
int Cod;
char Nombre[30];
char sexo;
int edad;
};
int main()
{ system("cls");
FILE *F;
personal reg,regtemporal,registro[dim];
int i,n,c=0,j,opc;
F = fopen("e:\\datos.txt","r"); // abre el archivo datos.txt
if (F == NULL)//Consistencia de exito de apertura del archivo

{
exit(1);
}
fread(&reg, sizeof(reg), 1, F); // aqui siempre debe empezar el ciclo de lectura
while(!feof(F))//crea el bucle mientras no sea el final del archivo

{ // guarda el registro leido en el arrays de estructuras
registro[c]=reg;
c=c+1;
fread(&reg,sizeof(reg),1,F); // lee el siguiente registro del archivo

fclose(F);
do
{system("cls");
cout<<"MENU DE OPCIONES"<<endl;
cout<<"ORDENAR POR"<<endl;
cout<<"\n[1]: Nombre ";
cout<<"\n[2]: Edad ";
cout<<"\n[3]: Sexo ";
cout<<"\n[4]: Finalizar ";
do
{cout<<"INGRESE UNA OPCION : ";
cin>>opc;
}while (opc<1 || opc>4);
// ordena los registros utilizando el array de estructuras
for(i=0;i<c;i++ )
for(j=i+1;j<c;j++)
switch(opc)
{case 1:
if (strcmp(registro[i].Nombre,registro[j].Nombre)>0)
}break;
case 2:
if(registro[i].edad >registro[j].edad)
}break;
case 3:
if(registro[i].sexo >registro[j].sexo)
}break;
case 4: system("cls");
cout<<"Fin proceso .... ";
system("pause");
break;
}
//Imprime los registros ordenados

system ("cls");
cout<<" LISTADO DEL PERSONAL
"<<endl<<endl<<endl;
cout<<"===================================================================\n";
cout<<"-----------------------------------------------------------------------\n";
for (i=0;i<c;i++)
cout<<setw(10)<<registro[i].Cod<<setw(20)<<registro[i].Nombre<<setw(10)<<registro[i].sexo<
<setw(10)<<registro[i].edad<<endl;
system ("pause");
}while (opc!=4);
return 0;
}
/* 1.- Altas 2.- Consultas 3.- Modificaciones 4.- Bajas logicas 5.- Listado
registros en un archivo binario secuencial*/ SECUENCI.CPP Rutinas de ...
#include <conio.h>
#include <stdio.h> // Para el manejo de archivos
#include <string.h> // Para el manejo de cadenas
#include <conio.h> // Para el manejo de clrscr
#include <iostream> // Para el manejo de cout
#include <ctype.h> // Para el uso de toupper
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct tipo_registro
{ // Campos:
int no_prod; // Numero de producto
char descrip[30]; // Descripcion del articulo
int cantidad; // Cantidad disponible en almacen
float precio; // Precio del articulo
char garantia; // Tiene garantia? [S/N]
};
tipo_registro Registro; // Declaracion global de la variable// "Registro" de tipo struct

tipo_registro
FILE *f; // Declaracion global de la variable "f" (apuntador a un// archivo
void ALTA_SECUENCIAL(); // Declaracion global de la rutina de Altas

void CONSULTA_SECUENCIAL(); // Declaracion global de la rutina de Consultas
void MODIFICACION_SECUENCIAL(); // Declaracion global de la rutina de Modificaciones
void BAJA_LOGICA_SECUENCIAL(); // Declaracion global de la rutina de Baja Logica
void BAJA_FISICA_SECUENCIAL(); // Declaracion global de la rutina de Baja Logica
void LISTADO_SECUENCIAL(); // Declaracion global de la rutina de Listado
int main()
{
int op;
do
{system("cls");
cout << "\n\n\r Programa que almacena datos de PRODUCTOS en un ARCHIVO SECUENCIAL";
cout << "\n\n\n\r 1.- Altas secuenciales";
cout << "\n\r 2.- Consultas secuenciales";
cout << "\n\r 3.- Modificaciones secuenciales";
cout << "\n\r 4.- Bajas logicas secuenciales";
cout << "\n\r 5.- Bajas fisicas (compactar archivo)";
cout << "\n\r 6.- Listado secuencial";
cout << "\n\r 0.- Salir";
cout << "\n\n\n\r Seleccione su opcion ---> ";
cin >> op;
switch(op)
{
case 1 : ALTA_SECUENCIAL(); break;
case 2 : CONSULTA_SECUENCIAL(); break;
case 3 : MODIFICACION_SECUENCIAL(); break;
case 4 : BAJA_LOGICA_SECUENCIAL(); break;
case 5 : BAJA_FISICA_SECUENCIAL(); break;
case 6 : LISTADO_SECUENCIAL(); break;
}
} while(op!=0);
return 0;
}
//----------------------------------------------------------------
void ALTA_SECUENCIAL()
{
int no_prod; // Variable local para el numero de producto
system("cls");
cout << "\n\rALTAS DE REGISTROS DE PRODUCTOS";

f=fopen("PRODUCTO.SEC","ab+"); // Intenta abrir el archivo PRODUCTO.SEC
// en modo de lectura/escritura
if (f==NULL)
{
cout<<"ERROR: El archivo no existe";
getch();
exit(1);
}
cout << "\n\n\n\rNumero de producto: ";

cin >> no_prod;
fread(&Registro,sizeof(Registro),1,f);
while(!feof(f)) // Ciclo mientras no se encuentre el final del archivo
{
if(Registro.no_prod==no_prod)
{
fclose(f);
getch();
return;
}
}
cout << "\n\rDescripcion: "; cin>>Registro.descrip;

cout << "\n\rCantidad : "; cin >> Registro.cantidad;
cout << "\n\rPrecio : "; cin >> Registro.precio;
do
{
cout << "\n\rGarantia : "; Registro.garantia=toupper(getche());
}while(Registro.garantia!='S' && Registro.garantia!='N');
Registro.no_prod=no_prod;
fwrite(&Registro,sizeof(Registro),1,f); // Grabar el Registro completo

fclose(f); // Cierra el archivo
cout << "\n\n\n\rProducto registrado !!!";

cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
return;
}
//----------------------------------------------------------------
void CONSULTA_SECUENCIAL()
{
int no_prod; // Variable local para el numero de producto que desea consultar
system("cls");
cout << "\n\rCONSULTA DE REGISTROS DE PRODUCTOS";

f=fopen("PRODUCTO.SEC","rb"); // Intenta abrir el archivo PRODUCTO.SEC
// en modo de solo lectura
if(f==NULL)
{
cout << "\n\n\n\rNo existe el archivo !!!";
getch();
return;
}
cout << "\n\n\n\rNumero de producto: "; cin >> no_prod;
// Lee el "Registro", de tamano=sizeof(Registro) del archivo "alias"
{
{
cout << "\n\rNo Prod Descripcion Cantidad Precio
Garantia";
cout << "\n\r-----------------------------------------------------------------------
-";
printf("\n\r%3d\t%30s\t%3d\t\t$%4.2f\t%c",Registro.no_prod,Registro.descrip,Registro.canti
dad,Registro.precio,Registro.garantia);
fclose(f);
getch();
return;
}
}
cout << "\n\rNo se encuentra ese registro !!!";

getch();
return;
}
//----------------------------------------------------------------
void MODIFICACION_SECUENCIAL()
{long dir_fisica;
int no_prod; // Variable local para el numero de producto que desea modificar
system("cls");
cout << "\n\rMODIFICACION DE REGISTROS DE PRODUCTOS";

f=fopen("PRODUCTO.SEC","rb+"); // Intenta abrir el archivo PRODUCTO.SEC
if(f==NULL) // Valida la existencia del archivo
{
getch();
return;
}
{
{
cout << "\n\rNo Prod Descripcion Cantidad Precio Garantia";
cout << "\n\r------------------------------------------------------------------------";
cout << "\n\n\n\rAnote los nuevos datos ...";

do
{cout << "\n\rGarantia : ";
Registro.garantia=toupper(getche());
// Es necesario reposicionar el apuntador del archivo al principio del

// registro que desea modificar, ya que al leer un registro, el
// apuntador se posiciona en el registro siguiente
// La funcion ftell(f) devuelve la posicion donde se encuentra el
// apuntador
fseek(f,ftell(f)-sizeof(Registro),SEEK_SET);
fwrite(&Registro,sizeof(Registro),1,f); // Graba el registro con
// los nuevos campos
cout << "\n\n\n\rRegistro modificado !!!";
getch();
return;
}
}
getch();return;
}
//----------------------------------------------------------------
void BAJA_LOGICA_SECUENCIAL()
{
int no_prod; // Variable local para el numero de producto que desea eliminar
char op; //Variable local
system("cls");
cout << "\n\rBAJAS LOGICAS DE REGISTROS DE PRODUCTOS";

f=fopen("PRODUCTO.SEC","rb+"); // Intenta abrir el archivo PRODUCTO.SEC
{
getch();
return;
}
{
{
cout << "\n\r------------------------------------------------------------------------";
Registro.no_prod=0;
strcpy(Registro.descrip,"");
Registro.cantidad=0;
Registro.precio=0.0;
Registro.garantia=' ';
do {
cout << "\n\n\rEsta seguro que desea borrarlo? [S/N] ---> ";
op=toupper(getche());
}while(op!='S' && op!='N');
if(op=='S')
{
// La funcion ftell(alias) devuelve la posicion donde se encuentra el
// apuntador
fseek(f,ftell(f)-sizeof(Registro),SEEK_SET);
fwrite(&Registro,sizeof(Registro),1,f);
// Graba el registro con los nuevos campos
cout << "\n\n\n\rRegistro eliminado !!!";
}

getch();
return;
}
}

getch();
return;
}
//----------------------------------------------------------------
void BAJA_FISICA_SECUENCIAL()
{
FILE *temporal;
//Declaracion local de una variable para controlar el archivo temporal
system("cls");
cout << "\n\rBAJAS FISICAS DE REGISTROS DE PRODUCTOS";
f=fopen("PRODUCTO.SEC","rb");
// Intenta abrir el archivo PRODUCTO.SEC en modo de solo lectura
{
getch();
return;
}
temporal=fopen("TEMPORAL.TMP","wb"); // Crea el archivo TEMPORAL.TMP
{
if(Registro.no_prod!=0)
fwrite(&Registro,sizeof(Registro),1,temporal);
// Graba el registro valido en el archivo temporal
}
fclose(f); // Cierra todos los archivos abiertos
fclose(temporal);
remove("PRODUCTO.SEC"); //Elimina el archivo original

rename("TEMPORAL.TMP","PRODUCTO.SEC");
//Renombra el archivo temporal con el nombre del archivo original
cout << "\n\n\n\rArchivo compactado !!!";

getch();
return;
}
//----------------------------------------------------------------
void LISTADO_SECUENCIAL()
{
system("cls");
cout << "\n\rLISTADO DE REGISTROS DE PRODUCTOS";

f=fopen("PRODUCTO.SEC","rb"); // Intenta abrir el archivo PRODUCTO.SEC
if(f==NULL)
{
getch();
return;
}

cout << "\n\r------------------------------------------------------------------------";
{//if( Registro.no_prod!=0)
}

cout << "\n\r------------------------------------------------------------------------";
cout << "\n\rFin del listado !!!";
getch();
return;
}
4.- Bajas logicas5.- Listado registros en un archivo binario relativo o de acceso
directo*/
#include <stdio.h> // Para el manejo de archivos
#include <string.h> // Para el manejo de cadenas
#include <conio.h> // Para el manejo de clrscr
#include <iostream> // Para el manejo de cout
#include <ctype.h> // Para el uso de toupper
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct tipo_registro
{ // Campos:
int no_prod; // Numero de producto
char descrip[30]; // Descripcion del articulo
int cantidad; // Cantidad disponible en almacen
float precio; // Precio del articulo
char garantia; // Tiene garantia? [S/N]
};
tipo_registro Registro;
// Declaracion global de la variable "Registro" de tipo struct tipo_registro
FILE *alias;
// Declaracion global de la variable "alias" (apuntador a un archivo
long int dir_fisica;
// Declaracion global de la variable para calcular la direccion fisica
void ALTA_DIRECTA(); // Declaracion global de la rutina de Altas

void CONSULTA_DIRECTA(); // Declaracion global de la rutina de Consultas
void MODIFICACION_DIRECTA(); // Declaracion global de la rutina de Modificaciones
void BAJA_LOGICA_DIRECTA(); // Declaracion global de la rutina de Baja Logica
void LISTADO_SECUENCIAL(); // Declaracion global de la rutina de Listado
//----------------------------------------------------------------
int main()
{
int op;
do
{
system("cls");
cout << "\n\n\r Programa que almacena datos de PRODUCTOS en un ARCHIVO DIRECTO";
cout << "\n\n\n\r 1.- Altas directas";
cout << "\n\r 2.- Consultas directas";
cout << "\n\r 3.- Modificaciones directas";
cout << "\n\r 4.- Bajas logicas directas";
cout << "\n\r 5.- Listado Secuencial";
cout << "\n\r 0.- Salir";

cin >> op;
switch(op)
{
case 1 : ALTA_DIRECTA(); break;
case 2 : CONSULTA_DIRECTA(); break;
case 3 : MODIFICACION_DIRECTA(); break;
case 4 : BAJA_LOGICA_DIRECTA(); break;
case 5 : LISTADO_SECUENCIAL(); break;
}
}while(op!=0);
return 0;
}
//----------------------------------------------------------------
void ALTA_DIRECTA()
{
int no_prod; // Variable local para el numero de producto
system("cls");
cout << "\n\rALTAS DE REGISTROS DE PRODUCTOS";

alias=fopen("PRODUCTO.DIR","ab+"); // Intenta abrir el archivo PRODUCTO.DIR
if(alias==NULL)
{cout<<"El archivo no existe ";
getche();
return;
}
//alias=fopen("PRODUCTO.DIR","wb"); // Crea el archivo en caso de no existir
dir_fisica=(no_prod-1)*sizeof(Registro); // Calculo de la dir. fisica
fseek(alias,dir_fisica,SEEK_SET);
//Posicionar el apuntador del archivo
fread(&Registro,sizeof(Registro),1,alias);
{
fclose(alias);
getch();
return;
}

do
{
cout << "\n\rGarantia : "; Registro.garantia=toupper(getche());
Registro.no_prod=no_prod;
fseek(alias,dir_fisica,SEEK_SET); //Posicionar el apuntador del archivo

fwrite(&Registro,sizeof(Registro),1,alias); // Grabar el Registro completo
cout << "\n\n\n\rProducto registrado !!!";
fclose(alias); // Cierra el archivo

getch();
}
//----------------------------------------------------------------
void CONSULTA_DIRECTA()
{
int no_prod; // Variable local para el numero de producto que desea consultar
system("cls");
cout << "\n\rCONSULTA DE REGISTROS DE PRODUCTOS";

alias=fopen("PRODUCTO.DIR","rb"); // Intenta abrir el archivo PRODUCTO.DIR
if(alias==NULL)
{
getch();
exit (0);
}

fseek(alias,dir_fisica,SEEK_SET);
//Posicionar el apuntador del archivo
{
cout << "\n\rNo Prod Descripcion Cantidad Precio
Garantia";
cout << "\n\r----------------------------------------------------------------
--------";
}
else
{
cout << "\n\n\n\rNo existe ese registro !!!";
}
fclose(alias);
cout << "\n\n\n\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
}
//----------------------------------------------------------------
void MODIFICACION_DIRECTA()
{
int no_prod; // Variable local para el numero de producto que desea modificar
system("cls");
cout << "\n\rMODIFICACION DE REGISTROS DE PRODUCTOS";

alias=fopen("PRODUCTO.DIR","rb+"); // Intenta abrir el archivo PRODUCTO.DIR
if(alias==NULL) // Valida la existencia del archivo
{
getch();
exit (0);
}

{
cout << "\n\r------------------------------------------------------------------------";
cout << "\n\n\n\rAnote los nuevos datos ...";

cout << "\n\rNo Prod "; cin>>Registro.no_prod;
do
{cout << "\n\rGarantia : ";
Registro.garantia=toupper(getche());
// La funcion ftell(alias) devuelve la posicion donde se encuentra el
// apuntador
fwrite(&Registro,sizeof(Registro),1,alias); // Graba el registro con
// los nuevos campos
cout << "\n\n\n\rRegistro modificado !!!";
getch();
}
else
{
cout << "\n\n\n\rNo se encuentra ese registro !!!";
}
getch();
}
//----------------------------------------------------------------
void BAJA_LOGICA_DIRECTA()
{ int no_prod; // Variable local para el numero de producto que desea eliminar
char op;
system("cls");
cout << "\n\rBAJA LOGICA DE REGISTROS DE PRODUCTOS";

alias=fopen("PRODUCTO.DIR","rb+"); // Intenta abrir el archivo PRODUCTO.DIR
if(alias==NULL) // Valida la existencia del archivo
{
getch();
exit (0);
}

{
cout << "\n\r------------------------------------------------------------------------";
printf("\n\r%3d\t%30s\t%3d\t\t$%4.2f\t%c\n\n\n\n\r",Registro.no_prod,Registro.descrip,Regi
stro.cantidad,Registro.precio,Registro.garantia);
Registro.no_prod=0;
strcpy(Registro.descrip,"");
Registro.cantidad=0;
Registro.precio=0.0;
Registro.garantia=' ';
Es necesario reposicionar el apuntador del archivo al principio del // registro que desea
modificar, ya que al leer un registro, el // apuntador se posiciona en el registro siguiente
// La funcion ftell(alias) devuelve la posicion donde se encuentra el // apuntador
do
{cout << "\n\rEsta seguro que desea eliminar este registro? [S/N] ---> ";
if(op=='S')
{fseek(alias,dir_fisica,SEEK_SET); //Posicionar el apuntador del archivo
fwrite(&Registro,sizeof(Registro),1,alias);
// Graba el registro con los nuevos campos
cout << "\n\n\n\rRegistro eliminado logicamente !!!";
}
else
cout << "\n\n\n\rRegistro NO eliminado !!!";

getch();
}
else
cout << "\n\n\n\rNo se encuentra ese registro !!!";

getch();
}
//----------------------------------------------------------------
void LISTADO_SECUENCIAL()
{
system("cls");
cout << "\n\rLISTADO DE REGISTROS DE PRODUCTOS";

alias=fopen("PRODUCTO.DIR","rb"); // Intenta abrir el archivo PRODUCTO.DIR
if(alias==NULL)
{
getch();
exit (0);
}

cout << "\n\r------------------------------------------------------------------------";
while(!feof(alias)) // Ciclo mientras no se encuentre el final del archivo
{
//if( Registro.no_prod!=0)
}

cout << "\n\r------------------------------------------------------------------------";
cout << "\n\rFin del listado !!!";
getch();
}
#include<iostream>
#include<string.h>
#include<conio.h>
#include<stdio.h>
#include<windows.h>
#include<iomanip>
struct alum
{
int cod;
char nom[20];
int au;
int gra;
char tur;
};
//----------------------------------------------------------------
void cargar()
{
cout<<"\n\n\n\n\n\n\n\n\n\n\t\t\t\tPresiona [Enter]\n";
cout<<"\t\t\t\tÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\n";getch();
cout<<"\t\t\t\t";
for(int i=0;i<14;i++)
{Sleep(100);
cout<<"¯";
}
system("cls");
}
//----------------------------------------------------------------
void cargar2()
{
cout<<"n\n\t\t\t Loading...\n";
cout<<"\t\t\t ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\n";
cout<<"\t\t\t ";
{Sleep(100);
cout<<"¯";
}
system("cls");
}
//----------------------------------------------------------------
int men()//********************************
{int op;
do{system("cls");system("color 9f");
cout<<"\n\n\n\t\t\t ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»"<<endl;
cout<<"\t\t\t ºMENU PRINCIPALº"<<endl;
cout<<"\t\t\tÉÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍ»"<<endl;
cout<<"\t\t\tº1.INGRESO DE ALUMNOS º"<<endl;
cout<<"\t\t\tÌÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ¹"<<endl;
cout<<"\t\t\tº2.LISTADO GENERAL º"<<endl;
cout<<"\t\t\tº3.BUSCAR POR CODIGO º"<<endl;
cout<<"\t\t\tº4.BUSCAR POR NOMBRE º"<<endl;
cout<<"\t\t\tº5.SALIR º"<<endl;
cout<<"\t\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ¼"<<endl;
cout<<"\n\t\t\tIngrese la opcion:";cin>>op;cin.ignore();
return op;}while(op<0||op>5);
}
//----------------------------------------------------------------
void ing()//****************
{system("cls");system("color 0f");
FILE *f;
alum r;
//duplicados
int codb;
f=fopen("E:\\algo.txt","a+");
if(f==NULL)
{ cout<<"\t\t\tError al intentar abrir el archivo\n";
getche();
exit(1);
}
cout<<"\n Ingrese el codigo a registrar ==> ";

cin>>codb;
fread(&r,sizeof(r),1,f);
while(!feof(f))
{if(r.cod==codb)
{cout<<" eL CODIGO YA ESTA REGISTRADO DUPLICADO ...";
getche();
return;
}
}
//fin duplicados//cout<<"\n\n\t\t\tCodigo:";cin>>r.cod;
cin.ignore();
r.cod=codb;
cout<<"\t\t\tNombre:";cin.getline(r.nom,20);
cout<<"\t\t\tAula:";cin>>r.au;
fflush(stdin);
do{cout<<"\t\t\tCiclo:";
cin>>r.gra;
}while(r.gra<0||r.gra>10);
fflush(stdin);
do{ cout<<"\t\t\tTurno:";
r.tur=toupper(getche());
}while(r.tur!='M'&&r.tur!='T'&&r.tur!='N');
fwrite(&r,sizeof(r),1,f);
cout<<"\n\t\t\tAlumno Registrado con exito";
fclose(f);
getch();
}
//----------------------------------------------------------------
void mos()//********************************
{system("cls");system("color bc");
FILE *f;
alum r;
cout<<"\n"<<setiosflags(ios::left)<<setw(10)<<"CODIGO"<<setw(20)<<"NOMBRE"<<setw(5)<<"AULA
"<<setw(6)<<"CICLO"<<setw(6)<<"TURNO"<<endl;
cout<<setiosflags(ios::left)<<setw(10)<<"ÍÍÍÍÍÍ"<<setw(20)<<"ÍÍÍÍÍÍ"<<setw(5)<<"ÍÍÍÍ"<<set
w(6)<<"ÍÍÍÍÍ"<<setw(6)<<"ÍÍÍÍÍ"<<endl;
f=fopen("H:\\algo.txt","r");
if(f==NULL)
cout<<"\t\t\tEl archivo no existe\n";
else
{fread(&r,sizeof(r),1,f);
while(!feof(f))
{cout<<setw(10)<<r.cod<<setw(20)<<r.nom<<setw(5)<<r.au<<setw(6)<<r.gra<<setw(6)<<r.tur<<en
dl;
}
fclose(f);
}
getch();
}
//----------------------------------------------------------------
void concod()//***********************
FILE *f;
alum r;
int codbus,i=0;
cout<<"\n\n\tIngrese el codigo a buscar:";cin>>codbus;cin.ignore();
cout<<endl;
if(f==NULL)
cout<<"\t\t\tEl archivo no existe\n";
else
{cout<<setw(10)<<"CODIGO"<<setw(20)<<"NOMBRE"<<setw(5)<<"AULA"<<setw(6)<<"CICLO"<<setw(6)<
<"TURNO"<<endl;
cout<<setw(10)<<"ÍÍÍÍÍÍ"<<setw(20)<<"ÍÍÍÍÍÍ"<<setw(5)<<"ÍÍÍÍ"<<setw(6)<<"ÍÍÍÍÍ"<<setw(6)<<
"ÍÍÍÍÍ"<<endl;
while(!feof(f))
{if(r.cod==codbus)
{i++;
cout<<setw(10)<<r.cod<<setw(20)<<r.nom<<setw(5)<<r.au<<setw(6)<<r.gra<<setw(6)<<r.tur<<end
l;
}
}
fclose(f);
if(i==0)
cout<<"\n\nEl codigo no existe\n";
else
cout<<"\n\nSe encontro "<<i<<" Alumno(s)\n";
}
getch();
}
//----------------------------------------------------------------
void connom()//***********************
FILE *f;
alum r;
char nombus[20];
int i=0;
cout<<"\n\n\tIngrese el nombre a buscar:";cin.getline(nombus,20);
cout<<endl;
if(f==NULL)
cout<<"\n\n\t\t\tEl archivo no existe\n";
else
{cout<<setw(10)<<"CODIGO"<<setw(20)<<"NOMBRE"<<setw(5)<<"AULA"<<setw(6)<<"CICLO"<<setw(6)<
<"TURNO"<<endl;
cout<<setw(10)<<"ÍÍÍÍÍÍ"<<setw(20)<<"ÍÍÍÍÍÍ"<<setw(5)<<"ÍÍÍÍ"<<setw(6)<<"ÍÍÍÍÍ"<<setw(6)<<
"ÍÍÍÍÍ"<<endl;
while(!feof(f))
{if(strcmp(r.nom,nombus)==0)
{i++;
cout<<setw(10)<<r.cod<<setw(20)<<r.nom<<setw(5)<<r.au<<setw(6)<<r.gra<<setw(6)<<r.tur<<end
l;
}
}
fclose(f);
if(i==0)
cout<<"\n\nEl nombre no existe\n";
else
cout<<"\n\nSe encontro "<<i<<" Alumno(s)\n";
}
getch();
}
//----------------------------------------------------------------
int main()
{ int op;
cargar();
do{op=men();
cargar2();
switch(op)
{case 1:ing();getch();break;
case 2:mos();getch();break;
case 3:concod();getch();break;
case 4:connom();getch();break;
}
}while(op!=5);
return 0;
}
#include<iostream> // DESAPROBADOS- COMPARAR CON EL OTRO ARTCHIVO ALUMNO y ARCHIVO.
#include<string.h>
#include<conio.h>
#include<stdlib.h>
#include<ctype.h>
#include<iomanip>
#define max 100
struct alumno
{int cod;
char nombre[20];
float ep,ef,pp,pl,pf;
char obs[15];
};
alumno a, temp[50],t;
FILE *f;
//----------------------------------------------------------------
int menu()
{int opcion;
cout<<"\t\t\tMENU PRINCIPAL"<<endl;
cout<<"\t\t\t=============="<<endl;
cout<<"[1]:Captura datos"<<endl;
cout<<"[2]:Mostrar Reporte"<<endl;
cout<<"[3]:Busqueda por codigo "<<endl;
cout<<"[4]:Busqueda por nombre "<<endl;
cout<<"[5]:Ordena alfabetico"<<endl;
cout<<"[6]:Ordena numerico"<<endl;
cout<<"[7]:Modificar campos"<<endl;
cout<<"[8]:Salir"<<endl;
do
{cout<<"Ingrese Una Opcion "<<endl;
cin>>opcion;
}while(opcion<1 || opcion>8);
return opcion;
}
//----------------------------------------------------------------
void ordena(float nota[],int n)
{int i,j;
float t;
for(i=0;i<5;i++)
for(j=i+1;j<5;j++)
if(nota[i]>nota[j])
{ t=nota[i];
nota[i]=nota[j];
nota[j]=t;
}
}
//----------------------------------------------------------------
float promedio(float nota[],int n)
{int i;
float pro,s,me;
s=0;
for(i=1;i<5;i++)// ordena(nota);
s=s+nota[i];
cout<<"suma : "<<s;getche();
pro=s/4;
return pro;
}
//----------------------------------------------------------------
void leernotas(float nota[], int n)
{int i;
for(i=0;i<5;i++)
{cout<<"nota ["<<i+1<<"]= ";
cin>>nota[i];
}
}
//----------------------------------------------------------------
void leer()
{int repite,codigo;
float nota[5];
do
{system("cls");
cout<<"Ingreso Informacion de los alumnos "<<endl;
cout<<"Codigo : ";
cin>>codigo;
f=fopen("alumnos.dat","ab+");
if (f==NULL)
{
cout<<"\n\n\n ERROR: No existe archivo";
getch();
exit(1);
}
fread(&a,sizeof(a),1,f);
while(!feof(f))
{
if(a.cod==codigo)
{
cout << "\n\n\n\r Registro duplicado";
fclose(f);
getch();
return;
}
}
a.cod=codigo;
cout<<"Nombres : "<<endl;
fflush(stdin);
gets(a.nombre);
do
{ cout<<"Exa.Parcial : "<<endl;
cin>>a.ep;
}while(a.ep<0 || a.ep>20);
do
{ cout<<"Exa.Final : "<<endl;
cin>>a.ef;
}while(a.ef<0 || a.ef>20);
cout<<"INGRESE LAS PRACTICAS DEL ALUMNO "<<endl;
leernotas(nota,5);
ordena(nota,5);
a.pp=promedio(nota,5);
cout<<"INGRESE LAS NOTAS DE LABORATORIO DEL ALUMNO "<<endl;
leernotas(nota,5);
ordena(nota,5);
a.pl=promedio(nota,5);
a.pf=(3*a.ep + 4*a.ef + a.pp + a.pl )/9;
if(a.pf>10.5)
strcpy(a.obs,"APROBADO");
else
strcpy(a.obs,"DESAPROBADO");
fwrite(&a,sizeof(a),1,f);
cout<<endl<<endl<<endl<<"\n\n\r -- REGISTRO ARCHIVADO CON EXITO\n";
fclose(f);
getch();
return;
cout<<"Desea Ingresar otro alumno Si 1 No 0 "<<endl;

cin>>repite;
}while(repite == 1);
}
//----------------------------------------------------------------
void mostraralum()
{
cout<<"\nCodigo ==> "<<a.cod<<endl;
cout<<"Nombre ==> "<<a.nombre<<endl;
cout<<"Nota del parcial ==> "<<a.ep<<endl;
cout<<"Nota del final ==> "<<a.ef<<endl;
cout<<"Promedio de nota de practicas ==> "<<a.pp<<endl;
cout<<"Promedio general ==> "<<a.pf<<endl;
cout<<"Observacion ==> "<<a.obs<<endl;
cout<<endl;
}
//----------------------------------------------------------------
void buscod() // BUSCAR X CODIGO
{
int nb,enc;
enc=0;
system("cls");
cout<<"\n\t\t\t\tBUSQUEDA POR CODIGO \n";
f=fopen("alumnos.dat","rb+");
if(f==NULL)
{
cout << "\n\n\n\r ERROR: No existe archivo";
getch();
return;
}
cout<<"\n Ingrese un codigo valido para buscar: ";

cin>>nb;
cout<<"\n\n\t\t\t\tMOSTRANDO DATOS: \n";
// cout<<"\t Cod.\tNombre\t\tEP\tEF\tPP\tPROMEDIO\n";
while(!feof(f))
{
if(a.cod==nb&& enc!=1)
//cout<<"\t "<<a.cod<<"\t"<<a.nom<<setw(16-
strlen(a.nom))<<"\t"<<a.ep<<"\t"<<a.ef<<"\t"<<a.pp<<"\t"<<a.pt<<"\t"<<endl;}
{ mostraralum();
enc=1;
}
}
if(enc==0)
cout<<"EL ALUMNO NO ESTA REGISTRADO !!!!!!!"<<endl;
getche();
fclose(f);
cout<<"\n ---FIN DE LA BUSQUEDA---\n";
getch();
return;
}
//----------------------------------------------------------------
void busnom() // BUSCAR X NOMBRE
{ char bus[50];
system("cls");
cout<<"\n\t\t\t\tBUSQUEDA POR NOMBRE \n";
if(f==NULL)
{
getch();
return;
}
cout<<"\n Ingrese un nombre valido para buscar: ";

fflush(stdin);
gets(bus);
cout<<"\n\n\t\t\t\tMOSTRANDO DATOS: \n";

// cout<<"\t Cod.\tNombre\t\tEP\tEF\tPP\tPROMEDIO\n";
while(!feof(f))
{
if(strcmp(bus,a.nombre)==0)
//{cout<<"\t
"<<a.cod<<"\t"<<a.nom<<"\t"<<a.ep<<"\t"<<a.ef<<"\t"<<a.pp<<"\t"<<a.pt<<"\t"<<endl;}
mostraralum();
}
cout<<"EL ALUMNO NO ESTA REGISTRADO !!!!!!!"<<endl;

getche();
fclose(f);
cout<<"\n ---FIN DE LA BUSQUEDA---\n";

getch();
return;
}
//----------------------------------------------------------------
void modificar() // MODIFICAR DATOS
{
int c,op;
system("cls");
cout<<"\n\t\t\t\tMODIFICAR DATOS \n";
if(f==NULL)
{
getch();
return;
}
cout<<"\n Ingrese un codigo valido: ";
cin>>c;
while(!feof(f))
{
if(a.cod==c)
{
mostraralum();
cout<<"\n\n Que Campos Desea Modificar \n\n";
cout<<"[1]: Codigo"<<endl;
cout<<"[2]: Nombres"<<endl;
cout<<"[3]: Ex.Parcial"<<endl;
cout<<"[4]: Ex.Final"<<endl;
cout<<"[5]: Pro.Practicas"<<endl;
cout<<"[5]: Pro.Laboratorio"<<endl;
do
{cout<<"Ingrese una opcion ";
cin>>op;
}while(op<1 || op >6);
switch(op)
{case 1: cout<<"Nuevo Codigo ";
cin>>a.cod;break;
case 2:cout<<" Nombre: ";
fflush(stdin);
gets(a.nombre);break;
case 3: do
{
cout<<" Notas: Ex. Parcial : ";
cin>>a.ep;
}while(a.ep<0||a.ep>20);break;
case 4: do
{
cout<<" Notas: Ex. Final : ";
cin>>a.ef;
}while(a.ef<0||a.ef>20);break;
case 5: do
{
cout<<" Notas: Prom. Pract. : ";
cin>>a.pp;
}while(a.pp<0||a.pp>20);break;
case 6: do
{
cout<<" Notas: Prom. Laboratorio. : ";
cin>>a.pl;
}while(a.pp<0||a.pp>20);break;
}
a.pf=int((2*a.ep+4*a.ef+a.pp)/7);
fseek(f,ftell(f)-sizeof(a),SEEK_SET);
fclose(f);
cout<<"\n\n -- NUEVO REGISTRO FINALIZADO CON EXITO\n";

getch();
return;
}
}
cout<<"\n\n CODIGO NO EXISTE";
fclose(f);
getch();
return;
}
//----------------------------------------------------------------
void mostrar() // MOSTRAR DATOS
{ int ap=0, desap=0;
system("cls");
cout<<"\n\t\t\t\tMOSTRANDO DATOS \n";
f=fopen("alumnos.dat","r");
if(f==NULL)
{
getch();
return;
}
cout<<setw(10)<<" CODIGO"<<setw(20)<<" NOMBRES"<<setw(10)<<" EX.PAR"<<setw(10)<<"
EX.FINAL"<<setw(10)<<"PROM.PRA"<<setw(10)<<
"PROM.FIN"<<setw(15)<<"OBSERVACION"<<endl;
while(!feof(f))
{
if(a.cod==0)
strcpy(a.obs,"Anulado");
else
{
if(a.pf>10.5)
{strcpy(a.obs,"Aprobado");
ap++;}
else
{strcpy(a.obs,"Reprobado");
desap++;}
}
cout<<setw(10)<<a.cod<<setw(20)<<a.nombre<<setw(10)<<a.ep<<setw(10)<<a.ef<<setw(10)<<a.pp<
<setw(10)<<
a.pf<<setw(15)<<a.obs<<endl;
}
fclose(f);
cout<<"\n\n\tTotal de aprobados : "<<ap;

cout<<"\n\tTotal de desaprobados : "<<desap;
getch();
return;
}
//----------------------------------------------------------------
void ord_nom() // ORDENAR
X NOMBRE
{
int final=0,ap=0,desap=0;
alumno t;
char est[10]="";
system("cls");
cout<<"\n\t\t\t\tMOSTRANDO DATOS: \n\n";
if(f==NULL)
{ cout << "\n\n\n\r ERROR: No existe archivo";
getch();
return;
}
cout<<"\t ³Cod.\tNombre\t\tEP\tEF\tPP\tPROMEDIO³\n";
int cont=0,tot=0;
int i,j;
while(!feof(f))
{
temp[cont]=a;
cont++;
}
fclose(f);
for(i=0;i<cont;i++)
for(j=i+1;j<cont;j++)
if(strcmp(temp[i].nombre,temp[j].nombre)>0)
{t=temp[i];
temp[i]=temp[j];
temp[j]=t;
}
for(i=0;i<cont;i++)
{
if(temp[i].cod!=0)
{
if(temp[i].pf>10.5)
{strcpy(est,"Aprob");
ap++;}
else
{strcpy(est,"Reprob");
desap++;}
cout<<"\t ³"<<temp[i].cod<<"\t"<<temp[i].nombre<<setw(16-
strlen(temp[i].nombre))<<"\t"<<temp[i].ep<<"\t"<<temp[i].ef<<"\t"<<temp[i].pp<<"\t"<<temp[
i].pf<<"\t³"<<endl;
}
}
cout<<"\n\nTotal de aprobados : "<<ap;

cout<<"\nTotal de desaprobados : "<<desap;
getch();
return;
}
//----------------------------------------------------------------
void ord_prom() // ORDENAR X PROMEDIO
{ int final=0,ap=0,desap=0;
alumno t;
char est[10]="";
system("cls");
cout<<"\n\t\t\t\tMOSTRANDO DATOS: \n\n";
if(f==NULL)
{
getch();
return;
}
cout<<"\t ³Cod.\tNombre\t\tEP\tEF\tPP\tPROMEDIO³\n";
int cont=0,tot=0;
int i,j;
while(!feof(f))
{
temp[cont]=a;
cont++;
}
fclose(f);
for(i=0;i<cont;i++)
for(j=i+1;j<cont;j++)
if(temp[i].pf>temp[j].pf)
{t=temp[i];
temp[i]=temp[j];
temp[j]=t;
}
for(i=0;i<cont;i++)
{ if(temp[i].cod!=0)
{ if(temp[i].pf>10.5)
{strcpy(est,"Aprob");
ap++;}
else
{strcpy(est,"Reprob");
desap++;}
cout<<"\t ³"<<temp[i].cod<<"\t"<<temp[i].nombre<<setw(16-
strlen(temp[i].nombre))<<"\t"<<temp[i].ep<<"\t"<<temp[i].ef<<"\t"<<temp[i].pp<<"\t"<<temp[
i].pf<<"\t³"<<endl;
}
}
cout<<"\n\nTotal de aprobados : "<<ap;

cout<<"\nTotal de desaprobados : "<<desap;
getch();
return;
}
//----------------------------------------------------------------
int main() // PRINCIPAL
{
alumno a[50];
int i, op;
system("color 1a");
system(" Practica Calificada 3 Con Archivos");
do
{system("cls");
op=menu();
switch(op)
{
case 1:leer(); break;
case 2:mostrar(); break;
case 3:buscod(); break;
case 4:busnom(); break;
case 5:ord_nom(); break;
case 6:ord_prom(); break;
case 7: modificar();break;
}
}while(op!=8);
system("cls");
for(i=0;i<100;i++)
cout<<"*";
cout<<endl<<"******************** FIN PROCESO *****************************"<<endl;
system("pause");
return 0;
}
#include <stdio.h>
#include <string.h> 1
#include <conio.h>
#include <iostream>
#include <ctype.h>
#include <iomanip>
struct articulos
{
int numero;
char descripcion[100];
float precio_anterior;
float precio_actual;
}articulo;
FILE *H;
void ingresar();
void modificar();
void eliminar();
void mostrar();
//----------------------------------------------------------------
int main()
{//system("color 1f");
int op;
do
{
system("cls");
cout << "\n\n\r <<PROGRAMA QUE MUESTRA PRECIO E INFLACION DE ARTICULOS>>";
cout << "\n\n\n\r 1.- Ingresar nuevo articulo.";
cout << "\n\r 2.- Modificar un articulo.";
cout << "\n\r 3.- eliminar un articulo.";
cout << "\n\r 4.- mostrar inflacion.";
cout << "\n\r 0.- Salir.";

cin >> op;
switch(op)
{
case 1 : ingresar(); break;
case 2 : modificar(); break;
case 3 : eliminar(); break;
case 4 : mostrar(); break;
}
}while(op!=0);
return 0;
}
//----------------------------------------------------------------
void ingresar()
{
int num;
system("cls");
cout << "\n\rIngresar nuevo articulo";
H=fopen("articulo.txt","ab+");
if (H==NULL)
{
getch();
exit(1);
}
cout << "\n\n\n\rNumero del articulo : "; cin>>num;
fread(&articulo,sizeof(articulo),1,H);
while(!feof(H))
{
if(articulo.numero==num)
{
fclose(H);
getch();
return;
}
}
cout << "\n\rDescripcion: "; cin>>articulo.descripcion;

cout << "\n\rPrecio anterior : "; cin >>articulo.precio_anterior;
cout << "\n\rPrecio actual : "; cin >>articulo.precio_actual;
articulo.numero=num;
fwrite(&articulo,sizeof(articulo),1,H);
cout << "\n\n\n\rArticulo registrado exitosamente.";

fclose(H);
getch();
return;
}
//----------------------------------------------------------------
void modificar()
{
int num;
system("cls");
cout << "\n\rModificar Articulos";

H=fopen("articulo.txt","rb+");
if(H==NULL)
{
getch();
return;
}
cout << "\n\n\n\rNumero del articulo "; cin>>num;
while(!feof(H))
{
{
cout <<
"\n\r"<<setw(10)<<"Numero"<<setw(15)<<"Articulo"<<setw(15)<<"P.anterior"<<setw(15)<<"P.act
ual";
cout << "\n\r------------------------------------------------------------------------
";
cout << "\n\r
"<<setw(10)<<articulo.numero<<setw(12)<<articulo.descripcion<<setw(12)<<articulo.precio_an
terior<<" $"<<setw(16)<<articulo.precio_actual<<" $";
cout << "\n\n\n\rAnote los nuevos datos :\n";

cout << "\n\rPrecio Anterior : "; cin >>articulo.precio_anterior;
cout << "\n\rPrecio Actual : "; cin >>articulo.precio_actual;
// cout<<ftell(H)<< " "<<sizeof(articulo);getche();
fseek(H,ftell(H)-sizeof(articulo),SEEK_SET);
fclose(H);
cout << "\n\n\rRegistro modificado.";
getch();
return;
}
}
fclose(H);
getch();
return;
}
//----------------------------------------------------------------
void eliminar()
{
int num;
char op;
system("cls");
cout << "\n\rEliminar un Articulo";

if(H==NULL)
{ cout << "\n\n\n\rNo existe el archivo.";
getch();
return;
}
cout << "\n\n\n\rNumero del Articulo : "; cin>>num;
while(!feof(H))
{
{
cout <<
ual";
cout << "\n\r------------------------------------------------------------------------
";
cout <<"\n\r
articulo.numero=0;
strcpy(articulo.descripcion,"");
articulo.precio_anterior=0.0;
articulo.precio_actual=0.0;
do
{
cout << "\n\n\rEsta seguro que desea borrarlo? (s/n) ---> ";
if(op=='S')
{
}
fclose(H);
getch();
return;
}
}
fclose(H);
getch();
return;
}
//----------------------------------------------------------------
void mostrar()
{
float inflacion=0,s=0,prom=0,promedio=0,max1=-100,inflamayor=0;
char artmax[100];
system("cls");
cout << "\n\r<<LISTADO DE REGISTROS DE ARTICULOS>>\n";

H=fopen("articulo.txt","r");
if(H==NULL)
{
getch();
return;
}
cout <<
ual"<<setw(15)<<"%inflacion";
cout << "\n\r------------------------------------------------------------------------
";
while(!feof(H))
{
if(articulo.numero!=0)
{
inflacion=(articulo.precio_actual-
articulo.precio_anterior)*100/articulo.precio_anterior;
s++;
prom=inflacion+prom;
if(inflacion>max1)
{ strcpy(artmax,articulo.descripcion);
inflamayor=inflacion;
max1=inflacion;
}
cout
<<"\n\r"<<setw(7)<<articulo.numero<<setw(16)<<articulo.descripcion<<setw(12)<<articulo.pre
cio_anterior<<" $"<<setw(16)<<articulo.precio_actual<<" $"<<setw(17)<<inflacion<<" %";
}
}
fclose(H);
cout << "\n\r------------------------------------------------------------------------";
promedio=prom/s;
cout<<"\n\nPromedio de inflacion : "<<promedio;
cout<<"\nArticulo con mayor inflacion : "<<artmax;
cout<<"\nPorcentaje con mayor inflacion : "<<inflamayor;
getch();
return;
}
#include <stdio.h>
#include <stdlib.h> 2
#include <string.h>
#include <conio.h>
#include <iostream>
#include <ctype.h>
#include <iomanip>
struct alumnos
{
int numero;
char nombre[100];
float calificacion1;
}alumno;
FILE *H;
void ingresar();
void modificar();
void eliminar();
void mostrar();
//----------------------------------------------------------------
int main()
{
system("color 3f");
int op;
do
{
system("cls");
cout << "\n\n\r <<PROGRAMA QUE MUESTRA PROMEDIO DE ALUMNOS>>";
cout << "\n\n\n\r 1.- Ingresar datos del alumno.";
cout << "\n\r 2.- Modificar un datos del alumno.";
cout << "\n\r 3.- eliminar un datos del alumno.";
cout << "\n\r 4.- mostrar promedios.";

cin >> op;
switch(op)
{
}
}while(op!=0);
return 0;
}
//----------------------------------------------------------------
void ingresar()
{
int num;
system("cls");
cout << "\n\rIngresar nuevas notas";
H=fopen("notas.txt","ab+");
if (H==NULL)
{
getch();
exit(1);
}
cout << "\n\n\n\rNumero del alumno : "; cin>>num;
fread(&alumno,sizeof(alumno),1,H);
while(!feof(H))
{
if(alumno.numero==num)
{
fclose(H);
getch();
return;
}
}
cout << "\n\rNombre : "; cin>>alumno.nombre;

cout << "\n\rCalificacion 1 : "; cin>>alumno.calificacion1;
alumno.numero=num;
fwrite(&alumno,sizeof(alumno),1,H);
cout << "\n\n\n\rAlumno registrado exitosamente.";

fclose(H);
getch();
return;
}
//----------------------------------------------------------------
void modificar()
{
int num;
system("cls");
H=fopen("notas.txt","rb+");
if(H==NULL)
{
getch();
return;
}
cout << "\n\n\n\rNumero del alumno "; cin>>num;
while(!feof(H))
{
{
cout <<
"\n\r"<<setw(10)<<"Numero"<<setw(15)<<"Nombre"<<setw(15)<<"Cal.1"<<setw(15)<<"Cal.2"<<"cal
.3";
cout << "\n\r------------------------------------------------------------------------
";
cout << "\n\r
"<<setw(10)<<alumno.numero<<setw(12)<<alumno.nombre<<setw(15)<<alumno.calificacion1<<setw(
12)<<alumno.calificacion2<<setw(16)<<alumno.calificacion3;

cout << "\n\rNombre : "; cin>>alumno.nombre;
cout << "\n\rCalificacion 1 : "; cin >>alumno.calificacion1;
fseek(H,ftell(H)-sizeof(alumno),SEEK_SET);
fclose(H);
getch();
return;
}
}
fclose(H);
getch();
return;
}
//----------------------------------------------------------------
void eliminar()
{
int num;
char op;
system("cls");
cout << "\n\rEliminar Notas";

H=fopen("notas.txt","rb+");
if(H==NULL)
{
cout << "\n\n\n\rNo existe el archivo.";
getch();
return;
}
cout << "\n\n\n\rNumero del Alumno : "; cin>>num;
while(!feof(H))
{
{
cout <<
"\n\r"<<setw(10)<<"Numero"<<setw(15)<<"Nombre"<<setw(15)<<"Cal.1"<<setw(15)<<"Cal.2"<<"cal
.3";
cout << "\n\r------------------------------------------------------------------------
";
cout << "\n\r
"<<setw(10)<<alumno.numero<<setw(12)<<alumno.nombre<<setw(15)<<alumno.calificacion1<<setw(
12)<<alumno.calificacion2<<setw(16)<<alumno.calificacion3;
alumno.numero=0;
strcpy(alumno.nombre,"");
alumno.calificacion1=0.0;
do
{cout << "\n\n\rEsta seguro que desea borrarlo? (s/n) ---> ";
if(op=='S')
{
fseek(H,ftell(H)-sizeof(alumno),SEEK_SET);
}
fclose(H);
getch();
return;
}
}
fclose(H);
getch();
return;
}
//----------------------------------------------------------------
void mostrar()
{
int final=0,aprob=0,desaprob=0;
char obs[10]="",artmax[100];
system("cls");
cout << "\n\r<<LISTADO DE PROMEDIOS DE LOS ALUMNOS>>\n";

H=fopen("notas.txt","r");
if(H==NULL)
{
getch();
return;
}
cout <<
"\n\r"<<setw(10)<<"Nombre"<<setw(10)<<"Cal.1"<<setw(10)<<"Cal.2"<<setw(10)<<"cal.3"<<setw(
12)<<"calc.final"<<setw(12)<<"observacion";
cout << "\n\r-----------------------------------------------------------------------------
";
while(!feof(H))
{
if(alumno.numero!=0)
{
final=int((alumno.calificacion1+2*alumno.calificacion2+2*alumno.calificacion3)/5);
if(final>10)
{ strcpy(obs,"Aprob");
aprob++;}
else
{strcpy(obs,"Reprob");
desaprob++;}
cout << "\n\r
"<<setw(10)<<alumno.nombre<<setw(9)<<alumno.calificacion1<<setw(9)<<alumno.calificacion2<<
setw(9)<<alumno.calificacion3<<setw(11)<<final<<setw(12)<<obs;
}
}
fclose(H);
cout << "\n\r-----------------------------------------------------------------------------
";
cout<<"\n\nTotal de aprobados : "<<aprob;
cout<<"\nTotal de desaprobados : "<<desaprob;
getch();
return;
}
#include<windows.h>
#include<math.h> 3
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<iomanip>
#include<string.h>
#include<ctype.h>
#include<iostream>
struct clientes
{
char nombre[30];
char direccion[20];
char articulo[20];
int cantidad;
float Precio_unitario;
}cliente;
FILE *H;
void ingresar();
void modificar();
void eliminar();
void mostrar();
//----------------------------------------------------------------
int main()
{
system("color 1f");
int op;
do
{
system("cls");
cout << "\n\n\r <<PROGRAMA QUE MUESTRA PEDIDOS>>";
cout << "\n\n\n\r 1.- Ingresar nuevo Pedido";
cout << "\n\r 2.- Modificar un Pedido.";
cout << "\n\r 3.- eliminar un Pedido.";
cout << "\n\r 4.- mostrar Pedido.";

cin >> op;
switch(op)
{
}
}while(op!=0);
return 0;
}
//----------------------------------------------------------------
void ingresar()
{
char nomb[30];
system("cls");
cout << "\n\rIngresar nuevo Nombre";

H=fopen("cliente.txt","ab+");
if (H==NULL)
{
getch();
exit(1);
}
cout << "\n\n\n\rNombre del cliente: "; cin>>nomb;
fread(&cliente,sizeof(cliente),1,H);
while(!feof(H))
{
if(strcmp(cliente.nombre,nomb)==0)
{
fclose(H);
getch();
return;
}
}
fflush(stdin);
cout << "\n\rDireccion : "; cin>>cliente.direccion;

cout << "\n\rArticulo : "; cin>>cliente.articulo; fflush(stdin);
cout << "\n\rCantidad : "; cin>>cliente.cantidad;
cout << "\n\rPrecio unitario : "; cin>>cliente.Precio_unitario;
strcpy(cliente.nombre,nomb);
fwrite(&cliente,sizeof(cliente),1,H);

fclose(H);
getch();
return;
}
//----------------------------------------------------------------
void modificar()
{ char nomb[30];
system("cls");
cout << "\n\rModificar Datos";

H=fopen("cliente.txt","rb+");
if(H==NULL)
{
getch();
return;
}
cout << "\n\n\n\rNombre: "; cin>>nomb;
while(!feof(H))
{
{

cout << "\n\rDireccion : "; cin>>cliente.direccion;
cout << "\n\rArticulo : "; cin>>cliente.articulo;
cout << "\n\rCantidad : "; cin>>cliente.cantidad;
cout << "\n\rPrecio Unitario : "; cin>>cliente.Precio_unitario;
fseek(H,ftell(H)-sizeof(cliente),SEEK_SET);
fclose(H);
getch();
return;
}
}
fclose(H);
getch();
return;
}
//----------------------------------------------------------------
void eliminar()
{
char nomb[30];
char op;
system("cls");
cout << "\n\rEliminar un Cliente";
H=fopen("cliente.txt","rb+");
if(H==NULL)
{
cout << "\n\n\n\rNo existe el archivo.";
getch();
return;
}
cout << "\n\n\n\rNombre del Cliente : "; cin>>nomb;
while(!feof(H))
{
{
strcpy(cliente.nombre,"");
strcpy(cliente.direccion,"");
strcpy(cliente.articulo,"");
cliente.cantidad=0;
cliente.Precio_unitario=0.0;
do
{ cout << "\n\n\rEsta seguro que desea borrarlo? (s/n) ---> ";
if(op=='S')
{fseek(H,ftell(H)-sizeof(cliente),SEEK_SET);
}
fclose(H);
getch();
return;
}
}
fclose(H);
getch();
return;
}
//----------------------------------------------------------------
void mostrar()
{
float total;
system("cls");
cout << "\n\r<<LISTADO DE CLIENTES>>\n";

H=fopen("cliente.txt","r");
if(H==NULL)
{
getch();
return;
}
cout <<
"\n\r"<<setw(10)<<"Nombre"<<setw(15)<<"Articulo"<<setw(15)<<"Cantidad"<<setw(15)<<"P.unita
rio"<<setw(15)<<"total";
cout << "\n\r------------------------------------------------------------------------";
while(!feof(H))
{
if(strcmp(cliente.nombre,"")!=0)
{total=cliente.cantidad*cliente.Precio_unitario;
cout
<<"\n\r"<<setw(7)<<cliente.nombre<<setw(16)<<cliente.articulo<<setw(12)<<cliente.cantidad<
<setw(16)<<cliente.Precio_unitario<<setw(17)<<total;
}
}
fclose(H);
cout << "\n\r------------------------------------------------------------------------";
getch();
return;
}
#include<windows.h>//BAJAS LOGICAS Y FISICAS
#include<math.h>
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
4
#include<conio.h> 3
#include<iomanip>
#include<string.h>
#include<ctype.h>
#include<iostream>
#define meses 12
struct data
{
char nom[30];
int produc[12];
float prom;
};
data obrero;
FILE *P;
FILE *G;
FILE *temporal;
void cargar();
void cargar2();
int menu();
void crear();
void ingresar();
void mostrar();
void modificar();
void baja_logica();
void baja_fisica();
//----------------------------------------------------------------
void cargar()
{
cout<<"\n\n\n\n\n\n\n\n\n\n\t\t\t\tPresiona [Enter]\n";
cout<<"\t\t\t\tÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\n";getch();
cout<<"\t\t\t\t";
{Sleep(100);
cout<<"¯";
}
system("cls");
}
//----------------------------------------------------------------
void cargar2()
{
cout<<"\n\n\t\t\t Loading...\n";
cout<<"\t\t\t ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\n";
cout<<"\t\t\t ";
{Sleep(100);
cout<<"¯";
}
system("cls");
}
//----------------------------------------------------------------
int menu()
{
int op;
do{
cout<<setw(50)<<"Elija una opcion\n\n";

cout<<setw(45)<<"1)Crear archivo.\n";
cout<<setw(50)<<"2)Ingresar los datos.\n";
cout<<setw(39)<<"3)Mostrar.\n";
cout<<setw(41)<<"4)Modificar.\n";
cout<<setw(45)<<"5)Bajas logicas.\n";
cout<<setw(45)<<"6)Bajas fisicas.\n";
cout<<setw(37)<<"0)Salir.\n";
cout<<"elija una opcion.\n";
cin>>op;
}while(op<0||op>6);
return(op);
}
//----------------------------------------------------------------
void crear()
{
P=fopen("prob4.txt","a+");
if(P==NULL)
{cout<<"el archivo no existe.\n";
getch();
exit(1);
}
else
{cout<<"se creo exitosamnte\n";
fclose(P);
}
getch();
}
//----------------------------------------------------------------
void ingresar()
{char resp;
int max=0,min;
P=fopen("prob4.txt","a");
if(P==NULL)
{
cout<<"ha ocurrido un error.\n";
getch();
exit(1);
}
do
{
cout<<endl;
cout<<"nombre del obrero: ";
cin>>obrero.nom;
for(int i=0;i<meses;i++)
{cout<<"Produccion en el mes ["<<i+1<<"] ";
cin>>obrero.produc[i];
}
{ if(obrero.produc[i]>max)
max=obrero.produc[i];
}
min=obrero.produc[0];
{if(min>obrero.produc[i])
min=obrero.produc[i];
}
obrero.prom=(max-min)*1000;
fwrite(&obrero,sizeof(obrero),1,P);
if(ferror(P))
{
cout<<"hay errores de escritura con el archivo.\n";
getch();
exit(1);
}
else
{cout<<"ingresar nuevo registro[S/N].\n";
cin>>resp;
resp=toupper(resp);
}
}while(resp!='N');
fclose(P);
}
//----------------------------------------------------------------
void mostrar()
{
P=fopen("prob4.txt","r+");
if(P==NULL)
{
cout<<"error.\n";
getch();
exit(1);
}
fread(&obrero,sizeof(obrero),1,P);
while(!feof(P))
{
cout<<endl;
cout<<"nombre: "<<obrero.nom<<endl;
cout<<"produccion por mes:\n";
{
cout<<"mes ["<<i+1<<"] "<<obrero.produc[i]<<endl;
}
cout<<"promedio: "<<obrero.prom;
cout<<endl;
}
fclose(P);
getch();
}
//----------------------------------------------------------------
void modificar()
{
char nombre[30];
int cont=0,max=0,min;
cout<<"ingrese el nombre a modificar.\n";
cin>>nombre;
if(P==NULL)
{
cout<<"error al abrir.\n";
getch();
exit(1);
}
G=fopen("temporal.txt","a+");
if(G==NULL)
{
cout<<"error en el archivo.\n";
getch();
exit(1);
}
while(!feof(P))
{ if(strcmp(nombre,obrero.nom)==0)
{
cout<<"ingrese nuevo nombre.\n";
cin>>obrero.nom;
{cout<<"produccion en el mes ["<<i+1<<"] ";
cin>>obrero.produc[i];//cout<<endl
}
{if(obrero.produc[i]>max)
max=obrero.produc[i];
}
min=obrero.produc[0];
{
if(min>obrero.produc[i])
min=obrero.produc[i];
}
obrero.prom=(max-min)*1000;
fwrite(&obrero,sizeof(obrero),1,G);
cont++;
}
else
fwrite(&obrero,sizeof(obrero),1,G);
}
fclose(P); fclose(G);
remove("prob4.txt"); rename("temporal.txt","prob4.txt");
if(cont==0)
cout<<"no existe ese nombre\n";
else
cout<<"fin de la modificacion\n"; system("pause");}
//----------------------------------------------------------------
void baja_logica()
{
char nombre[30];
char resp;
if(P==NULL)
{
cout<<"el archivo no existe.\n";
getch();
exit(1);
}
cout<<"nombre del obrero.\n";

cin>>nombre;
while(!feof(P))
{
if(strcmp(obrero.nom,nombre)==0)
{ cout<<"nombre: "<<obrero.nom<<endl;
cout<<"produccion por mes:\n";
cout<<"mes ["<<i+1<<"] "<<obrero.produc[i]<<endl;
cout<<"promedio: "<<obrero.prom;
strcpy(obrero.nom,"");
obrero.produc[i]=0;
obrero.prom=0;
do
{ cout<<endl<<"esta seguro que desea eliminarlo[S/N].\n";
resp=toupper(getche());
}while((resp!='S')&&(resp!='N'));
if(resp=='S')
{
fseek(P,ftell(P)-sizeof(obrero),SEEK_SET);
fwrite(&obrero,sizeof(obrero),1,P);
cout<<endl<<"registro eliminado.\n";
}
fclose(P);
getch();
return;
}
}

fclose(P);

getch();
return;}
//----------------------------------------------------------------
void baja_fisica()
{ system("cls");
cout << "\n\rBAJAS FISICAS DE REGISTROS DE PRODUCTOS";

P=fopen("prob4.txt","r");
if(P==NULL)
{
getch();
return;
}
temporal=fopen("temporal.txt","w");
while(!feof(P))
{
if(strcmp(obrero.nom,"")!=0)
fwrite(&obrero,sizeof(obrero),1,temporal);
}
fclose(P);
fclose(temporal);
remove("prob4.txt");
rename("temporal.txt","prob4.txt");
cout << "\n\n\n\rArchivo compactado !!!";

getch();
return;
}
//----------------------------------------------------------------
int main()
{ system ("color 1a");

int op;
cargar();
do{
system("cls");
op=menu();
cargar2();
switch(op)
{
case 1: crear(); break;
case 2: ingresar(); break;
case 3: mostrar(); break;
case 4: modificar(); break;
case 5: baja_logica(); break;
case 6: baja_fisica(); break;
case 0: break;
}
}while(op!=0);
cout<<"fin del programa.\n";
system ("pause");
return (0);
}
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <iostream>
#include <ctype.h>
#include <iomanip> 5
4
struct articulos
{
int numero;
char descripcion[100];
float precio_anterior;
float precio_actual;
}articulo;
FILE *H;
void ingresar();
void modificar();
void eliminar();
void mostrar();
//----------------------------------------------------------------
int main()
{//system("color 1f");
int op;
do
{
system("cls");
cout << "\n\n\r <<PROGRAMA QUE MUESTRA PRECIO E INFLACION DE ARTICULOS>>";
cout << "\n\n\n\r 1.- Ingresar nuevo articulo.";
cout << "\n\r 2.- Modificar un articulo.";
cout << "\n\r 3.- eliminar un articulo.";
cout << "\n\r 4.- mostrar inflacion.";

cin >> op;
switch(op)
{
}
}while(op!=0);
return 0;
}
//----------------------------------------------------------------
void ingresar()
{
int num;
system("cls");
cout << "\n\rIngresar nuevo articulo";
H=fopen("articulo.txt","ab+");
if (H==NULL)
{
getch();
exit(1);
}
cout << "\n\n\n\rNumero del articulo : "; cin>>num;
while(!feof(H))
{
{
fclose(H);
getch();
return;
}
}

cout << "\n\rPrecio anterior : "; cin >>articulo.precio_anterior;
cout << "\n\rPrecio actual : "; cin >>articulo.precio_actual;
articulo.numero=num;

fclose(H);
getch();
return;
}
//----------------------------------------------------------------
void modificar()
{
int num;
system("cls");

if(H==NULL)
{
getch();
return;
}
cout << "\n\n\n\rNumero del articulo "; cin>>num;
while(!feof(H))
{
{
cout <<
ual";
cout << "\n\r------------------------------------------------------------------------
";
cout << "\n\r

cout << "\n\rPrecio Anterior : "; cin >>articulo.precio_anterior;
cout << "\n\rPrecio Actual : "; cin >>articulo.precio_actual;
// cout<<ftell(H)<< " "<<sizeof(articulo);getche();
fclose(H);
getch();
return;
}
}
fclose(H);
getch();
return;
}
//----------------------------------------------------------------
void eliminar()
{
int num;
char op;
system("cls");
cout << "\n\rEliminar un Articulo";

if(H==NULL)
{ cout << "\n\n\n\rNo existe el archivo.";
getch();
return;
}
cout << "\n\n\n\rNumero del Articulo : "; cin>>num;
while(!feof(H))
{
{
cout <<
ual";
cout << "\n\r------------------------------------------------------------------------
";
cout <<"\n\r
articulo.numero=0;
strcpy(articulo.descripcion,"");
articulo.precio_anterior=0.0;
articulo.precio_actual=0.0;
do
{
cout << "\n\n\rEsta seguro que desea borrarlo? (s/n) ---> ";
if(op=='S')
{
}
fclose(H);
getch();
return;
}
}
fclose(H);
getch();
return;
}
//----------------------------------------------------------------
void mostrar()
{
float inflacion=0,s=0,prom=0,promedio=0,max1=-100,inflamayor=0;
char artmax[100];
system("cls");
cout << "\n\r<<LISTADO DE REGISTROS DE ARTICULOS>>\n";

H=fopen("articulo.txt","r");
if(H==NULL)
{
getch();
return;
}
cout <<
ual"<<setw(15)<<"%inflacion";
cout << "\n\r------------------------------------------------------------------------
";
while(!feof(H))
{
if(articulo.numero!=0)
{
inflacion=(articulo.precio_actual-
articulo.precio_anterior)*100/articulo.precio_anterior;
s++;
prom=inflacion+prom;
if(inflacion>max1)
{ strcpy(artmax,articulo.descripcion);
inflamayor=inflacion;
max1=inflacion;
}
cout
<<"\n\r"<<setw(7)<<articulo.numero<<setw(16)<<articulo.descripcion<<setw(12)<<articulo.pre
cio_anterior<<" $"<<setw(16)<<articulo.precio_actual<<" $"<<setw(17)<<inflacion<<" %";
}
}
fclose(H);
cout << "\n\r------------------------------------------------------------------------";
promedio=prom/s;
cout<<"\n\nPromedio de inflacion : "<<promedio;
cout<<"\nArticulo con mayor inflacion : "<<artmax;
cout<<"\nPorcentaje con mayor inflacion : "<<inflamayor;
getch();
return;
}
#include <iostream>
#include <iomanip>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include <conio.h>
#define max 10
struct empleado
{int cod;
char nom[20];
float sue,afp,imp,neto;
};
//-------------------------------------------------
FILE *f,*g;
empleado a,t,reg[max];
int menu()
{int op;
cout<<"\t\t\t MENU PRINCIPAL"<<endl;
cout<<"\t\t[1] Captura de datos "<<endl;
cout<<"\t\t[2] Mostrar Reporte "<<endl;
cout<<"\t\t[3] Busqueda por nombre "<<endl;
cout<<"\t\t[4] Busqueda por odigo "<<endl;
cout<<"\t\t[5] Ordena alfabético "<<endl;
cout<<"\t\t[6] Ordenar por sueldo neto "<<endl;
// cout<<"\t\t[6] Modificar campos "<<endl;*/
cout<<"\t\t[7] Salir "<<endl;
do
{cout<<"\nIngrese una opcion : ===> ";
cin>>op;
}while(op<1 || op >7);
return op;
}
//-------------------------------------------------
void cargar()
{int codigo,op;
do
{system("cls");
cout<<"Ingrese datos del empleado"<<endl;
cout<<"codigo : ";
cin>>codigo;
f = fopen("E:\\sueldo.dat","ab+");
if(f==NULL)
{cout<<"No existe el archivo "<<endl;
getche();
exit (1);
}
while(!feof(f))
{if(a.cod==codigo)
{cout<<"Codigo duplicado !!!!!"<<endl;
fclose(f);
getche();
exit(1);
}
}
cout<<"Nombre : ";
fflush(stdin);
gets(a.nom);
do
{ cout<<"Sueldo bruto : ";
cin>>a.sue;
}while(a.sue <0);
a.afp=a.sue*3/100;
a.imp=a.sue*1/100;
a.neto=a.sue-(a.imp+a.afp);
a.cod=codigo;
cout<<"Registro archivado con exito "<<endl;
getche();
fclose(f);
cout<<"Hay mas datos Si [1] No [0] ";
cin>>op;
}while(op==1);
}
//-------------------------------------------------
void mostrar1()
{ cout<<"\n";
cout<<"Codigo ==> "<<a.cod<<endl;
cout<<"Nombre ==> "<<a.nom<<endl;
cout<<"Sueldo bruto ==> "<<a.sue<<endl;
cout<<"Descuento por AFP ==> "<<a.afp<<endl;
cout<<"Descuento por impuesto a la remuneracion ==> "<<a.imp<<endl;
cout<<"Sueldo Neto ==> "<<a.neto<<endl;
cout<<endl;
}
//-------------------------------------------------
void mostrar()
{
float sumasue,sumaafp,sumaimp,sumanet;
sumasue=sumaafp=sumaimp=sumanet=0;
f=fopen("E:\\sueldo.dat","rb");
if(f==NULL)
getche();
exit (0);
}
cout<<setw(8)<<" CODIGO"<<setw(15)<<" NOMBRES"<<setw(10)<<" S.
BRUTO"<<setw(10)<<"D.AFP"<<setw(10)<<"IMP.REMUN"<<setw(10)<<"NETO"<<endl;
cout<<"________________________________________________________________"<<endl;
while(!feof(f))
{
sumasue=sumasue+a.sue;
sumaafp=sumaafp+a.afp;
sumaimp=sumaimp+a.imp;
sumanet=sumanet+a.neto;
cout<<"\n";
cout<<setw(8)<<a.cod<<setw(15)<<a.nom<<setw(10)<<a.sue<<setw(10)<<a.afp<<setw(10)<<a.imp<<
setw(10)<<a.neto<<endl;
}
cout<<"________________________________________________________________"<<endl;
cout<<setw(8)<<"TOTALES"<<setw(15)<<"
"<<setw(10)<<sumasue<<setw(10)<<sumaafp<<setw(10)<<sumaimp<<setw(10)<<sumanet<<endl;
fclose(f);
}
//-------------------------------------------------
void mostrareg(empleado r[],int n)
{int i;
float sumasue,sumaafp,sumaimp,sumanet;
sumasue=sumaafp=sumaimp=sumanet=0;
cout<<setw(8)<<" CODIGO"<<setw(15)<<" NOMBRES"<<setw(10)<<" S.

BRUTO"<<setw(10)<<"D.AFP"<<setw(10)<<"IMP.REMUN"<<setw(10)<<"NETO"<<endl;
cout<<"________________________________________________________________"<<endl;
for(i=0;i<n;i++)
{ sumasue=sumasue+r[i].sue;
sumaafp=sumaafp+r[i].afp;
sumaimp=sumaimp+r[i].imp;
sumanet=sumanet+r[i].neto;
cout<<"\n";
cout<<setw(8)<<r[i].cod<<setw(15)<<r[i].nom<<setw(10)<<r[i].sue<<setw(10)<<r[i].afp<<setw(
10)<<r[i].imp<<setw(10)<<r[i].neto<<endl;
}
}
//-------------------------------------------------
int busqueda()
{ int e;
char nomb[20];
e=0;
cout<<"\n";
cout<<"\tDigite el Nombre a buscar: ";
fflush(stdin);
gets(nomb);
if(f==NULL)
getche();
exit (0);
}
while(!feof(f))
{if(strcmp(a.nom,nomb)==0)
{e=1;
mostrar1();
}
}
if(e==0)
cout<<"el registro no esta registrdo"<<endl;
getche();
fclose(f);
}
//-------------------------------------------------
int buscod()
{ int e;
int codigo;
e=0;
cout<<"\n";
cout<<"\tDigite el Codigo a buscar: ";
cin>>codigo;
if(f==NULL)
getche();
exit (0);
}
while(!feof(f))
{if(a.cod==codigo)
{e=1;
mostrar1();
}
}
if(e==0)
cout<<"el registro no esta registrdo"<<endl;
getche();
fclose(f);
}
//-------------------------------------------------
void ordenaalfabetico()
{int i,j,c;
c=0;
if(f==NULL)
getche();
exit (0);
}
while(!feof(f))
{reg[c]=a;
c=c+1;
}
fclose(f);
for(i=0;i<c;i++)
for(j=i+1;j<c;j++)
if(strcmp(reg[i].nom,reg[j].nom)>0)
{t=reg[i];
reg[i]=reg[j];
reg[j]=t;
}
mostrareg(reg,c);
}
//-------------------------------------------------
void ordenanumerico()
{int i,j,c;
c=0;
if(f==NULL)
getche();
exit (0);
}
while(!feof(f))
{reg[c]=a;
c=c+1;
}
fclose(f);
for(i=0;i<c;i++)
for(j=i+1;j<c;j++)
if(reg[i].sue>reg[j].sue>0)
{t=reg[i];
reg[i]=reg[j];
reg[j]=t;
}
mostrareg(reg,c);
}
//-------------------------------------------------
int main()
{
int opcion;
do
{system("cls");
opcion=menu();
switch(opcion)
{case 1: cargar();break;
case 2: mostrar();system("pause");break;
case 3: busqueda();
break;
case 4: buscod();
break;
case 5:
cout<<"\t\t\tLISTADO EN ORDEN ALFABETICO"<<endl;
cout<<"\t\t\t==========================="<<endl;
ordenaalfabetico();
system("pause");break;
case 6: cout<<"\n";
cout<<" SUELDO ORDENADO "<<endl;
cout<<"==========================="<<endl;
ordenanumerico();
system("pause");break;
// case 6: modificardato(per,n); break;*/
}
}while(opcion !=7);
system("cls");
cout<<"************FIN PROCESO ***************"<<endl;
system("pause");
return 0;
}

Recuperación Al Instante de PROBLEMAS - Asd

Загружено:

Сведения о документе

Исходное описание:

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Recuperación Al Instante de PROBLEMAS - Asd

Загружено:

Авторское право:

Доступные форматы

#include <iostream>

#define archivo "f:\\Alumnos.dat"

cout<<"Ingrese el codigo a registrar : ";

//Consistencia de exito de apertura del archivo

while(!feof(F)) // Ciclo mientras no se encuentre el final del archivo

cout<<"Desea Ingresar Otro registro (S/N)? ";

cout<<"Ingrese el codigo a registrar : ";

//Consistencia de exito de apertura del archivo

fread(&A,sizeof(A),1,F);// Lee el "Registro", de tamano=sizeof(Registro) del archivo

while(!feof(F)) // Ciclo mientras no se encuentre el final del archivo

cout<<"Desea Ingresar Otro registro (S/N)? ";

//Consistencia de exito de apertura del archivo

// aqui siempre debe empezar el ciclo de lectura

cout<<"Desea realizar otra busqueda si=1 no = 0)"<<endl;

cout<<"Ingrese Codigo a Eliminar ---> ";

fread(&A, sizeof(A), 1, F);

rename(archivo1, archivo); //Cambia de nombre

cout<<"Desea actualizar otro campo ? Si [1] No [0] ";

fread(&A,sizeof(A),1,F);// Lee el "Registro", de tamano=sizeof(Registro)

while(!feof(F)) // Ciclo mientras no se encuentre el final del archivo

// captura de campos de datos

cout<<"Nombre ---> ";

fwrite(&A, sizeof(A), 1, F); // grabando a disco

cout<<"Desea Ingresar Otro registro (S/N)? ";

}while(rpta == 'S' || rpta == 's');

fread(&A, sizeof(A), 1, F);

cout<<"Desea relizar otra busqueda si=1 no = 0)"<<endl;

cout<<"Nomre a buscar ---> ";

cout<<"Desea relizar otra busqueda si=1 no = 0)"<<endl;

cout<<"Desea realizar otra busqueda si=1 no = 0)"<<endl;

cout<<"Ingrese Codigo a Eliminar ---> ";

fwrite(&A, sizeof(A), 1, G);

rename(archivo1, archivo); //Cambia de nombre

fread(&A, sizeof(A), 1, F);

fwrite(&A, sizeof(A), 1, G);

cout<<"Desea modificar otro campo 1/0 "<<endl;

fread(&A, sizeof(A), 1, F);

// crea el bucle para ingresar varios registros

cout<<"Nombre ---> ";//Evita que salte

cout<<"Sexo [M/F] -----> ";

cout<<"Edad -----> ";

fwrite(&reg, sizeof(reg), 1, F);

cout<<"Desea Ingresar Otro registro (S/N)? ";

// aqui siempre debe empezar el ciclo de lectura

if (F == NULL)//Consistencia de exito de apertura del archivo

fread(&reg, sizeof(reg), 1, F); // aqui siempre debe empezar el ciclo de lectura

while(!feof(F))//crea el bucle mientras no sea el final del archivo

fread(&reg,sizeof(reg),1,F); // lee el siguiente registro del archivo

//Imprime los registros ordenados

using namespace std;

tipo_registro Registro; // Declaracion global de la variable// "Registro" de tipo struct

FILE *f; // Declaracion global de la variable "f" (apuntador a un// archivo

void ALTA_SECUENCIAL(); // Declaracion global de la rutina de Altas

cout << "\n\rALTAS DE REGISTROS DE PRODUCTOS";

cout << "\n\n\n\rNumero de producto: ";

cout << "\n\rDescripcion: "; cin>>Registro.descrip;

fwrite(&Registro,sizeof(Registro),1,f); // Grabar el Registro completo

cout << "\n\n\n\rProducto registrado !!!";

cout << "\n\rCONSULTA DE REGISTROS DE PRODUCTOS";

cout << "\n\n\n\rNumero de producto: "; cin >> no_prod;

cout << "\n\rNo se encuentra ese registro !!!";

cout << "\n\rMODIFICACION DE REGISTROS DE PRODUCTOS";