Vous êtes sur la page 1sur 84

#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>
using namespace std;
#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);
}
// captura de campos de datos
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>
using namespace std;
#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;
// 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);
}
// captura de campos de datos
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>
#include <iomanip>
using namespace std;
#define archivo "E:\\Alumnos.dat"

struct ALUMNO
{
int Cod;
char Nombre[30];
int Nota;
};

int main()
{system("cls");

FILE *F;
ALUMNO A;
F = fopen(archivo,"r+");

//Consistencia de exito de apertura del archivo


if (F == NULL)
{
printf("No se puede abrir el archivo\n");
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";
fread(&A,sizeof(A),1,F);
} // 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
F = fopen(archivo,"r+");

if (F == NULL)
{
printf("No se encontro Archivo, No se puede abrir el archivo\n");
getche();
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
encontrado = 0;

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

while(!feof(F))
{ // desplegando Registro Buscado
if(A.Nota >= Nota)

{encontrado = 1;
cout<<setw(10)<<A.Cod<<setw(20)<<A.Nombre<<setw(10)<<A.Nota<<endl;

cout<<"\n";
}
fread(&A, sizeof(A), 1, F);
} // aqui termina while
// no olvidar cerrar archivo y siempre fuera de while
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;
//abriendo, leyendo,cargando estructura
F = fopen(archivo,"r+");

if (F == NULL)
{
cout<<"No se puede abrir el archivo\n";
getche();
exit(1);
}

G = fopen(archivo1,"a+");

if (G == NULL)
{
cout<<"No se puede abrir el archivo\n";
getche();
exit(1);
}
cout<<"=================================================\n";
cout<<setw(10)<<"Codigo"<<setw(20)<<"Nombre"<<setw(10)<<"Nota\n";
cout<<"-------------------------------------------------\n";

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

while(!feof(F))
{ // Registro Buscado
if(Codigo != A.Cod)
fwrite(&A, sizeof(A), 1, G);
else
encontrado =1;
fread(&A, sizeof(A), 1, F);
}
// no olvidar cerrar archivo y siempre fuera de while
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>
using namespace std;
#define archivo "E:\\Alumnos.dat"
#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;
int encontrado=0, Codigo;
cout<<"Codigo a Actualizar ---> ";
cin>>Codigo;
//abriendo, leyendo,cargando estructura
F = fopen(archivo,"r+");
if (F == NULL)
{
cout<<"No se puede abrir el archivo\n";

system ("pause");
exit(1);
}

G = fopen(archivo1,"a+");
if (G == NULL)
{
cout<<"No se puede abrir el archivo\n";
exit(1);
system ("pause");
}

cout<<"======================================================\n";
cout<<setw(10)<<"Codigo"<<setw(20)<<"Nombre"<<setw(10)<<"Nota\n";
cout<<"-------------------------------------------------------\n";
fread(&A, sizeof(A), 1, F);
while(!feof(F))
{ // Registro Buscado
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;
fwrite(&A, sizeof(A), 1, G);
}
else
fwrite(&A, sizeof(A), 1, G);
fread(&A, sizeof(A), 1, F);
}
// no olvidar cerrar archivo y siempre fuera de while
fclose(F);
fclose(G);

remove(archivo); // Elimina
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 archivo "E:\\Alumnos.dat"
#define archivo1 "E:\\temporal.dat"
using namespace std;
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;
// 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();
return;
}
fread(&A,sizeof(A),1,F);
}

// captura de campos de datos


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);

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

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


cin>>rpta;

fclose(F);

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


//avisando usuario
cout<<"Alumno Archivado\n\n";
system ("pause");
system ("pause");
}
//-------------------------------------------------------------
void MostrarData()
{system("cls");
FILE *F;
ALUMNO A;
F = fopen(archivo,"r+");
//Consistencia de exito de apertura del archivo
if (F == NULL)
{
printf("No se puede abrir el archivo\n");
getche();
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

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";
fread(&A,sizeof(A),1,F);
}; // aqui termina while
// no olvidar cerrar archivo y siempre fuera de while
system ("pause");
fclose(F);
printf("\n\n");
system ("pause");
}
//--------------------------------------------------------------
void Buscarxcodigo()
{system("cls");
FILE *F;
ALUMNO A;

int Codigo,encontrado,rep=1;
do
{
// cargando clave a buscar
cout<<"Codigo a buscar ---> ";
cin>>Codigo;
//abriendo, leyendo,cargando estructura
F = fopen(archivo,"r+");

if (F == NULL)
{
printf("No se puede abrir el archivo\n");
getche();
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

encontrado = 0;

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

while(!feof(F))
{ // desplegando Registro Buscado
if(A.Cod == Codigo)
{encontrado = 1;
cout<<setw(10)<<A.Cod<<setw(20)<<A.Nombre<<setw(10)<<A.Nota<<endl;
cout<<"\n";
}
fread(&A, sizeof(A), 1, F);
}; // aqui termina while
// no olvidar cerrar archivo y siempre fuera de while
if (encontrado == 0)
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");
cout<<"Fin Busqueda "<<endl;
system ("pause");
fclose(F);
}
//-----------------------------------------------------------------
void Buscarxnombre()
{system("cls");
FILE *F;
ALUMNO A;
char nom[30];
int encontrado,rep=1;
do
{
// cargando clave a buscar
cin.ignore();

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


cin.getline(nom,30);
//abriendo, leyendo,cargando estructura
F = fopen(archivo,"r+");

if (F == NULL)
{
printf("No se puede abrir el archivo\n");
getche();
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

encontrado = 0;

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

while(!feof(F))
{ // desplegando Registro Buscado
if(strcmp(A.Nombre,nom)==0)

{encontrado = 1;
cout<<setw(10)<<A.Cod<<setw(20)<<A.Nombre<<setw(10)<<A.Nota<<endl;

cout<<"\n";
}
fread(&A, sizeof(A), 1, F);
}; // aqui termina while
// no olvidar cerrar archivo y siempre fuera de while
if (encontrado == 0)
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");
cout<<"Fin Busqueda "<<endl;
system ("pause");
fclose(F);
}
//-----------------------------------------------------------------
void BuscarFiltroData()
{system("cls");
FILE *F;
ALUMNO A;

int Nota,encontrado,rep=1;
do
{
// cargando clave a buscar
cout<<"Nota >= --> ";
cin>>Nota;
//abriendo, leyendo,cargando estructura
F = fopen(archivo,"r+");

if (F == NULL)
{
printf("No se puede abrir el archivo\n");
getche();
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
encontrado = 0;

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

while(!feof(F))
{ // desplegando Registro Buscado
if(A.Nota >= Nota)
{encontrado = 1;
cout<<setw(10)<<A.Cod<<setw(20)<<A.Nombre<<setw(10)<<A.Nota<<endl;
cout<<"\n";
}
fread(&A, sizeof(A), 1, F);
} // aqui termina while
// no olvidar cerrar archivo y siempre fuera de while
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);
}
//------------------------------------------------------------
void EliminarData()
{system("cls");
FILE *F;
FILE *G;
ALUMNO A;
char op;
int encontrado=0, Codigo;

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


cin>>Codigo;
//abriendo, leyendo,cargando estructura
F = fopen(archivo,"r+");

if (F == NULL)
{ cout<<"No se puede abrir el archivo\n";
getche();
exit(1);}

G = fopen(archivo1,"a+");

if (G == NULL)
{ cout<<"No se puede abrir el archivo\n";
getche();
exit(1);
}

cout<<"=================================================\n";
cout<<setw(10)<<"Codigo"<<setw(20)<<"Nombre"<<setw(10)<<"Nota\n";
cout<<"-------------------------------------------------\n";
fread(&A, sizeof(A), 1, F);
while(!feof(F))
{ // Registro Buscado
if(Codigo != A.Cod)
{

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

}
else
encontrado =1;
fread(&A, sizeof(A), 1, F);
}
// no olvidar cerrar archivo y siempre fuera de while
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");
}
//----------------------------------------------------------------
void ModificarData()
{int resp;
system("cls");
FILE *F;
FILE *G;
ALUMNO A;
int Hallado=0, Codigo,op;
// cargando clave a buscar
cout<<"Codigo a Editar ---> ";
cin>>Codigo;
//abriendo, leyendo,cargando estructura
F = fopen(archivo,"r+");

if (F == NULL)
{
printf("No se puede abrir el archivo\n");
getche();
exit(1);
}

G = fopen(archivo1,"a+");

if (G == NULL)
{
printf("No se puede abrir el archivo\n");
exit(1);
}
printf("========================================\n");
printf("Codigo\t\tNombre\t\tNota\n");
printf("----------------------------------------\n");

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

while(!feof(F))
{ // Registro Buscado
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;
}

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

Hallado = 1;

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


cin>>resp;
if(resp==0)break;
}
cout<<"Fin de modificacion"<<endl;
getche();
}
else
fwrite(&A, sizeof(A), 1, G);

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


} // aqui termina while
// no olvidar cerrar archivo y siempre fuera de while
fclose(F);
fclose(G);
//Removiendo y eliminando
//Recordar que los nombres Directorios/carpetas y Archivos de datos no
// 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>
using namespace std;
#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+");
//Consistencia de exito de apertura del archivo

// crea el bucle para ingresar varios registros


if (F == NULL)
{
cout<<"No se puede abrir el archivo\n";
system("pause");
exit(1);
}

fread(&reg,sizeof(reg),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(reg.Cod==codigo)
{
cout << "\n\n\n\rRegistro duplicado !!!";
fclose(F);
getch();
exit(1);
}
fread(&reg,sizeof(reg),1,F);
}

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);

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


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
using namespace std;

struct personal
{
int Cod;
char Nombre[30];
char sexo;
int edad;
};

int main()
{system("cls");
FILE *F;
personal reg;
char rpta;
// abre el archivo datos.txt
F = fopen("E:\\datos.txt","r");
//Consistencia de exito de apertura del archivo
if (F == NULL)
{
printf("No se puede abrir el archivo\n");
getche();
exit(1);
}

system ("cls");
cout<<"===================================================================\n";
cout<<setw(10)<<"Codigo"<<setw(20)<<"Nombre"<<setw(10)<<"Sexo"<<setw(10)<<"Edad\n";
cout<<"-----------------------------------------------------------------------\n";
// aqui siempre debe empezar el ciclo de lectura
fread(&reg, sizeof(reg), 1, F);
//crea el bucle mientras no sea el final del archivo
while(!feof(F))
{ // desplegando estructuras

cout<<setw(10)<<reg.Cod<<setw(20)<<reg.Nombre<<setw(10)<<reg.sexo<<setw(10)<<reg.edad<<end
l;
cout<<"\n";
fread(&reg,sizeof(reg),1,F);
} // 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
using namespace std;
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;
// abre el archivo datos.txt
F = fopen("E:\\datos.txt","r");
//Consistencia de exito de apertura del archivo
if (F == NULL)
{
printf("No se puede abrir el archivo\n");
getche();
exit(1);
}

// aqui siempre debe empezar el ciclo de lectura


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
fread(&reg,sizeof(reg),1,F);
} // aqui termina while
// no olvidar cerrar archivo y siempre fuera de while
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<<setw(10)<<"Codigo"<<setw(20)<<"Nombre"<<setw(10)<<"Sexo"<<setw(10)<<"Edad\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>
using namespace std;
#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;
// abre el archivo datos.txt
F = fopen("e:\\datos.txt","r"); // abre el archivo datos.txt

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


{
printf("No se puede abrir el archivo\n");
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


} // aqui termina while
// no olvidar cerrar archivo y siempre fuera de while

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)
{regtemporal=registro[i];
registro[i]=registro[j];
registro[j]=regtemporal;
}break;

case 2:

if(registro[i].edad >registro[j].edad)
{regtemporal=registro[i];
registro[i]=registro[j];
registro[j]=regtemporal;
}break;

case 3:

if(registro[i].sexo >registro[j].sexo)
{regtemporal=registro[i];
registro[i]=registro[j];
registro[j]=regtemporal;
}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<<setw(10)<<"Codigo"<<setw(20)<<"Nombre"<<setw(10)<<"Sexo"<<setw(10)<<"Edad\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>

using namespace std;

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);
// Lee el "Registro", de tamano=sizeof(Registro) del archivo "f"
while(!feof(f)) // Ciclo mientras no se encuentre el final del archivo
{
if(Registro.no_prod==no_prod)
{
cout << "\n\n\n\rRegistro duplicado !!!";
fclose(f);
getch();
return;
}
fread(&Registro,sizeof(Registro),1,f);
}

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 !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
return;
}

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

fread(&Registro,sizeof(Registro),1,f);
// Lee el "Registro", de tamano=sizeof(Registro) del archivo "alias"
while(!feof(f)) // Ciclo mientras no se encuentre el final del archivo
{
if(Registro.no_prod==no_prod)
{
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);
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
return;
}
fread(&Registro,sizeof(Registro),1,f);
}

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


fclose(f); // Cierra el archivo
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
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
// en modo de lectura/escritura
if(f==NULL) // Valida la existencia del archivo
{
cout << "\n\n\n\rNo existe el archivo !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
return;
}

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

fread(&Registro,sizeof(Registro),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(Registro.no_prod==no_prod)
{
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);

cout << "\n\n\n\rAnote los nuevos datos ...";


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');

// 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
fclose(f); // Cierra el archivo
cout << "\n\n\n\rRegistro modificado !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
return;
}
fread(&Registro,sizeof(Registro),1,f);
}
cout << "\n\rNo se encuentra ese registro !!!";
fclose(f); // Cierra el archivo
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
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
// en modo de lectura/escritura
if(f==NULL) // Valida la existencia del archivo
{
cout << "\n\n\n\rNo existe el archivo !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
return;
}

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

fread(&Registro,sizeof(Registro),1,f);
// Lee el "Registro", de tamano=sizeof(Registro) del archivo "alias"
while(!feof(f)) // Ciclo mientras no se encuentre el final del archivo
{
if(Registro.no_prod==no_prod)
{
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);

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')
{
// 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
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 !!!";
}

fclose(f); // Cierra el archivo


cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
return;
}
fread(&Registro,sizeof(Registro),1,f);
}

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


fclose(f); // Cierra el archivo
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
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
if(f==NULL) // Valida la existencia del archivo
{
cout << "\n\n\n\rNo existe el archivo !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
return;
}

temporal=fopen("TEMPORAL.TMP","wb"); // Crea el archivo TEMPORAL.TMP

fread(&Registro,sizeof(Registro),1,f);
// Lee el "Registro", de tamano=sizeof(Registro) del archivo "alias"
while(!feof(f)) // Ciclo mientras no se encuentre el final del archivo
{
if(Registro.no_prod!=0)
fwrite(&Registro,sizeof(Registro),1,temporal);
// Graba el registro valido en el archivo temporal

fread(&Registro,sizeof(Registro),1,f);
}

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 !!!";


cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
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
// en modo de solo lectura
if(f==NULL)
{
cout << "\n\n\n\rNo existe el archivo !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
return;
}

cout << "\n\rNo Prod Descripcion Cantidad Precio Garantia";


cout << "\n\r------------------------------------------------------------------------";
fread(&Registro,sizeof(Registro),1,f);
// Lee el "Registro", de tamano=sizeof(Registro) del archivo "alias"
while(!feof(f)) // Ciclo mientras no se encuentre el final del archivo
{//if( Registro.no_prod!=0)

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);
fread(&Registro,sizeof(Registro),1,f);
}

fclose(f); // Cierra el archivo


cout << "\n\r------------------------------------------------------------------------";
cout << "\n\rFin del listado !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
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>
using namespace std;

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";

cout << "\n\n\n\r Seleccione su opcion ---> ";


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
// en modo de lectura/escritura
if(alias==NULL)
{cout<<"El archivo no existe ";
getche();
return;
}
//alias=fopen("PRODUCTO.DIR","wb"); // Crea el archivo en caso de no existir

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

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);
// Lee el "Registro", de tamano=sizeof(Registro) del archivo "alias"
if(Registro.no_prod==no_prod)
{
cout << "\n\n\n\rRegistro duplicado !!!";
fclose(alias);
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;

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 !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";

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
// en modo de solo lectura
if(alias==NULL)
{
cout << "\n\n\n\rNo existe el archivo !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
exit (0);
}

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

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);
// Lee el "Registro", de tamano=sizeof(Registro) del archivo "alias"
if(Registro.no_prod==no_prod)
{
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);
}
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
// en modo de lectura/escritura
if(alias==NULL) // Valida la existencia del archivo
{
cout << "\n\n\n\rNo existe el archivo !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
exit (0);
}

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

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);
// Lee el "Registro", de tamano=sizeof(Registro) del archivo "alias"
if(Registro.no_prod==no_prod)
{
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);

cout << "\n\n\n\rAnote los nuevos datos ...";


cout << "\n\rNo Prod "; cin>>Registro.no_prod;
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');
// 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
fseek(alias,dir_fisica,SEEK_SET); //Posicionar el apuntador del archivo
fwrite(&Registro,sizeof(Registro),1,alias); // Graba el registro con
// los nuevos campos
fclose(alias); // Cierra el archivo
cout << "\n\n\n\rRegistro modificado !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();

}
else
{
cout << "\n\n\n\rNo se encuentra ese registro !!!";
}
fclose(alias); // Cierra el archivo
cout << "\n\n\n\n\r<<< Oprima cualquier tecla para continuar >>>";
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
// en modo de lectura/escritura
if(alias==NULL) // Valida la existencia del archivo
{
cout << "\n\n\n\rNo existe el archivo !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
exit (0);
}

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

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);
// Lee el "Registro", de tamano=sizeof(Registro) del archivo "alias"
if(Registro.no_prod==no_prod)
{
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\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] ---> ";
op=toupper(getche());
}while(op!='S' && op!='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 !!!";

fclose(alias); // Cierra el archivo


cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
}
else
cout << "\n\n\n\rNo se encuentra ese registro !!!";

fclose(alias); // Cierra el archivo


cout << "\n\n\n\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
}
//----------------------------------------------------------------
void LISTADO_SECUENCIAL()
{
system("cls");

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


alias=fopen("PRODUCTO.DIR","rb"); // Intenta abrir el archivo PRODUCTO.DIR
// en modo de solo lectura
if(alias==NULL)
{
cout << "\n\n\n\rNo existe el archivo !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
exit (0);
}

cout << "\n\rNo Prod Descripcion Cantidad Precio Garantia";


cout << "\n\r------------------------------------------------------------------------";
fread(&Registro,sizeof(Registro),1,alias);
// Lee el "Registro", de tamano=sizeof(Registro) del archivo "alias"
while(!feof(alias)) // Ciclo mientras no se encuentre el final del archivo
{
//if( Registro.no_prod!=0)

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);
fread(&Registro,sizeof(Registro),1,alias);
}

fclose(alias); // Cierra el archivo


cout << "\n\r------------------------------------------------------------------------";
cout << "\n\rFin del listado !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();

}
#include<iostream>
#include<string.h>
#include<conio.h>
#include<stdio.h>
#include<windows.h>
#include<iomanip>
using namespace std;

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 ";
for(int i=0;i<14;i++)
{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ÌÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͹"<<endl;
cout<<"\t\t\tº3.BUSCAR POR CODIGO º"<<endl;
cout<<"\t\t\tÌÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͹"<<endl;
cout<<"\t\t\tº4.BUSCAR POR NOMBRE º"<<endl;
cout<<"\t\t\tÌÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͹"<<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;
}
fread(&r,sizeof(r),1,f);
}
//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;
fread(&r,sizeof(r),1,f);
}
fclose(f);
}
getch();
}
//----------------------------------------------------------------
void concod()//***********************
{system("cls");system("color 0f");
FILE *f;
alum r;
int codbus,i=0;
cout<<"\n\n\tIngrese el codigo a buscar:";cin>>codbus;cin.ignore();
cout<<endl;
f=fopen("H:\\algo.txt","r");
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;
fread(&r,sizeof(r),1,f);
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;
}
fread(&r,sizeof(r),1,f);
}
fclose(f);
if(i==0)
cout<<"\n\nEl codigo no existe\n";
else
cout<<"\n\nSe encontro "<<i<<" Alumno(s)\n";
}
getch();
}
//----------------------------------------------------------------
void connom()//***********************
{system("cls");system("color 0f");
FILE *f;
alum r;
char nombus[20];
int i=0;
cout<<"\n\n\tIngrese el nombre a buscar:";cin.getline(nombus,20);
cout<<endl;
f=fopen("H:\\algo.txt","r");
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;
fread(&r,sizeof(r),1,f);
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;
}
fread(&r,sizeof(r),1,f);
}
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>
using namespace std;
#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;
}
fread(&a,sizeof(a),1,f);
}

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";
fread(&a,sizeof(a),1,f);

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;
}
fread(&a,sizeof(a),1,f);
}

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";
f=fopen("alumnos.dat","rb+");

if(f==NULL)
{
cout << "\n\n\n\r ERROR: No existe archivo";
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";

fread(&a,sizeof(a),1,f);

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();
fread(&a,sizeof(a),1,f);
}

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";
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: ";
cin>>c;
fread(&a,sizeof(a),1,f);

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);
fwrite(&a,sizeof(a),1,f);
fclose(f);

cout<<"\n\n -- NUEVO REGISTRO FINALIZADO CON EXITO\n";


getch();
return;
}
fread(&a,sizeof(a),1,f);
}
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)
{
cout << "\n\n\n\r ERROR: No existe archivo";
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;

fread(&a,sizeof(a),1,f);

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;

fread(&a,sizeof(a),1,f);
}
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";

f=fopen("alumnos.dat","r");

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;

fread(&a,sizeof(a),1,f);

while(!feof(f))
{
temp[cont]=a;

cont++;
fread(&a,sizeof(a),1,f);
}

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";

f=fopen("alumnos.dat","r");

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;

fread(&a,sizeof(a),1,f);

while(!feof(f))
{
temp[cont]=a;

cont++;
fread(&a,sizeof(a),1,f);
}
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>

using namespace std;

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.";

cout << "\n\n\n\r Seleccione su opcion ---> ";


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)
{
cout<<"ERROR: El archivo no existe";
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)
{
cout << "\n\n\n\rRegistro duplicado !!!";
fclose(H);
getch();
return;
}
fread(&articulo,sizeof(articulo),1,H);
}

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)
{
cout << "\n\n\n\rNo existe el archivo !!!";
getch();
return;
}

cout << "\n\n\n\rNumero del articulo "; cin>>num;

fread(&articulo,sizeof(articulo),1,H);

while(!feof(H))
{
if(articulo.numero==num)
{
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\rDescripcion: "; cin>>articulo.descripcion;
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);
fwrite(&articulo,sizeof(articulo),1,H);

fclose(H);
cout << "\n\n\rRegistro modificado.";
getch();
return;
}
fread(&articulo,sizeof(articulo),1,H);
}
cout << "\n\rNo se encuentra ese registro !!!";
fclose(H);
getch();
return;
}
//----------------------------------------------------------------
void eliminar()
{
int num;
char op;
system("cls");

cout << "\n\rEliminar un Articulo";


H=fopen("articulo.txt","rb+");

if(H==NULL)
{ cout << "\n\n\n\rNo existe el archivo.";
getch();
return;
}
cout << "\n\n\n\rNumero del Articulo : "; cin>>num;

fread(&articulo,sizeof(articulo),1,H);

while(!feof(H))
{
if(articulo.numero==num)
{
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<<" $";
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) ---> ";
op=toupper(getche());
}while(op!='S' && op!='N');

if(op=='S')
{
fseek(H,ftell(H)-sizeof(articulo),SEEK_SET);
fwrite(&articulo,sizeof(articulo),1,H);
cout << "\n\n\n\rRegistro eliminado !!!";
}

fclose(H);
getch();
return;
}
fread(&articulo,sizeof(articulo),1,H);
}
cout << "\n\rNo se encuentra ese registro !!!";
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)
{
cout << "\n\n\n\rNo existe el archivo !!!";
getch();
return;
}

cout <<
"\n\r"<<setw(10)<<"Numero"<<setw(15)<<"Articulo"<<setw(15)<<"P.anterior"<<setw(15)<<"P.act
ual"<<setw(15)<<"%inflacion";
cout << "\n\r------------------------------------------------------------------------
";
fread(&articulo,sizeof(articulo),1,H);

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<<" %";
}
fread(&articulo,sizeof(articulo),1,H);
}

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>

using namespace std;

struct alumnos
{
int numero;
char nombre[100];
float calificacion1;
float calificacion2;
float calificacion3;

}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.";
cout << "\n\r 0.- Salir.";

cout << "\n\n\n\r Seleccione su opcion ---> ";


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 nuevas notas";

H=fopen("notas.txt","ab+");

if (H==NULL)
{
cout<<"ERROR: El archivo no existe";
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)
{
cout << "\n\n\n\rRegistro duplicado !!!";
fclose(H);
getch();
return;
}
fread(&alumno,sizeof(alumno),1,H);
}

cout << "\n\rNombre : "; cin>>alumno.nombre;


cout << "\n\rCalificacion 1 : "; cin>>alumno.calificacion1;
cout << "\n\rCalificacion 2 : "; cin>>alumno.calificacion2;
cout << "\n\rCalificacion 3 : "; cin>>alumno.calificacion3;

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");

cout << "\n\rModificar Articulos";

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;

fread(&alumno,sizeof(alumno),1,H);

while(!feof(H))
{
if(alumno.numero==num)
{
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\n\n\rAnote los nuevos datos :\n";


cout << "\n\rNombre : "; cin>>alumno.nombre;
cout << "\n\rCalificacion 1 : "; cin >>alumno.calificacion1;
cout << "\n\rCalificacion 2 : "; cin >>alumno.calificacion2;
cout << "\n\rCalificacion 3 : "; cin >>alumno.calificacion3;

fseek(H,ftell(H)-sizeof(alumno),SEEK_SET);
fwrite(&alumno,sizeof(alumno),1,H);

fclose(H);
cout << "\n\n\rRegistro modificado.";
getch();
return;
}
fread(&alumno,sizeof(alumno),1,H);
}
cout << "\n\rNo se encuentra ese registro !!!";
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;

fread(&alumno,sizeof(alumno),1,H);

while(!feof(H))
{
if(alumno.numero==num)
{
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;
alumno.calificacion2=0.0;
alumno.calificacion3=0.0;
do
{cout << "\n\n\rEsta seguro que desea borrarlo? (s/n) ---> ";
op=toupper(getche());
}while(op!='S' && op!='N');

if(op=='S')
{
fseek(H,ftell(H)-sizeof(alumno),SEEK_SET);
fwrite(&alumno,sizeof(alumno),1,H);
cout << "\n\n\n\rRegistro eliminado !!!";
}

fclose(H);
getch();
return;
}
fread(&alumno,sizeof(alumno),1,H);
}
cout << "\n\rNo se encuentra ese registro !!!";
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)
{
cout << "\n\n\n\rNo existe el archivo !!!";
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-----------------------------------------------------------------------------
";

fread(&alumno,sizeof(alumno),1,H);

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;
}
fread(&alumno,sizeof(alumno),1,H);
}

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>

using namespace std;

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.";
cout << "\n\r 0.- Salir.";

cout << "\n\n\n\r Seleccione su opcion ---> ";


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()
{
char nomb[30];
system("cls");

cout << "\n\rIngresar nuevo Nombre";


H=fopen("cliente.txt","ab+");

if (H==NULL)
{
cout<<"ERROR: El archivo no existe";
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)
{
cout << "\n\n\n\rRegistro duplicado !!!";
fclose(H);
getch();
return;
}
fread(&cliente,sizeof(cliente),1,H);
}
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);

cout << "\n\n\n\rArticulo registrado exitosamente.";


fclose(H);

getch();
return;
}
//----------------------------------------------------------------
void modificar()
{ char nomb[30];

system("cls");

cout << "\n\rModificar Datos";


H=fopen("cliente.txt","rb+");

if(H==NULL)
{
cout << "\n\n\n\rNo existe el archivo !!!";
getch();
return;
}

cout << "\n\n\n\rNombre: "; cin>>nomb;

fread(&cliente,sizeof(cliente),1,H);

while(!feof(H))
{
if(strcmp(cliente.nombre,nomb)==0)
{

cout << "\n\n\n\rAnote los nuevos datos :\n";


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);
fwrite(&cliente,sizeof(cliente),1,H);

fclose(H);
cout << "\n\n\rRegistro modificado.";
getch();
return;
}
fread(&cliente,sizeof(cliente),1,H);
}
cout << "\n\rNo se encuentra ese registro !!!";
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;

fread(&cliente,sizeof(cliente),1,H);

while(!feof(H))
{
if(strcmp(cliente.nombre,nomb)==0)
{
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) ---> ";
op=toupper(getche());
}while(op!='S' && op!='N');

if(op=='S')
{fseek(H,ftell(H)-sizeof(cliente),SEEK_SET);
fwrite(&cliente,sizeof(cliente),1,H);
cout << "\n\n\n\rRegistro eliminado !!!";
}

fclose(H);
getch();
return;
}
fread(&cliente,sizeof(cliente),1,H);
}
cout << "\n\rNo se encuentra ese registro !!!";
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)
{
cout << "\n\n\n\rNo existe el archivo !!!";
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------------------------------------------------------------------------";

fread(&cliente,sizeof(cliente),1,H);

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;
}
fread(&cliente,sizeof(cliente),1,H);
}

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
using namespace std;
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";
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 ";
for(int i=0;i<14;i++)
{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];
}

for(int i=0;i<meses;i++)
{ if(obrero.produc[i]>max)
max=obrero.produc[i];
}

min=obrero.produc[0];

for(int i=0;i<meses;i++)
{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";
for(int i=0;i<meses;i++)
{
cout<<"mes ["<<i+1<<"] "<<obrero.produc[i]<<endl;
}

cout<<"promedio: "<<obrero.prom;

fread(&obrero,sizeof(obrero),1,P);
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;
P=fopen("prob4.txt","r+");
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);
}

fread(&obrero,sizeof(obrero),1,P);

while(!feof(P))
{ if(strcmp(nombre,obrero.nom)==0)
{
cout<<"ingrese nuevo nombre.\n";
cin>>obrero.nom;
for(int i=0;i<meses;i++)
{cout<<"produccion en el mes ["<<i+1<<"] ";
cin>>obrero.produc[i];//cout<<endl
}
for(int i=0;i<meses;i++)
{if(obrero.produc[i]>max)
max=obrero.produc[i];
}

min=obrero.produc[0];

for(int i=0;i<meses;i++)
{
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);

fread(&obrero,sizeof(obrero),1,P);
}
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;

P=fopen("prob4.txt","r+");

if(P==NULL)
{
cout<<"el archivo no existe.\n";
getch();
exit(1);
}

cout<<"nombre del obrero.\n";


cin>>nombre;

fread(&obrero,sizeof(obrero),1,P);

while(!feof(P))
{
if(strcmp(obrero.nom,nombre)==0)
{ cout<<"nombre: "<<obrero.nom<<endl;
cout<<"produccion por mes:\n";

for(int i=0;i<meses;i++)
cout<<"mes ["<<i+1<<"] "<<obrero.produc[i]<<endl;

cout<<"promedio: "<<obrero.prom;

strcpy(obrero.nom,"");

for(int i=0;i<meses;i++)
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);
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
return;
}
fread(&obrero,sizeof(obrero),1,P);
}

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


fclose(P);

cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";


getch();
return;}
//----------------------------------------------------------------
void baja_fisica()
{ system("cls");

cout << "\n\rBAJAS FISICAS DE REGISTROS DE PRODUCTOS";


P=fopen("prob4.txt","r");

if(P==NULL)
{
cout << "\n\n\n\rNo existe el archivo !!!";
cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
getch();
return;
}

temporal=fopen("temporal.txt","w");
fread(&obrero,sizeof(obrero),1,P);

while(!feof(P))
{
if(strcmp(obrero.nom,"")!=0)
fwrite(&obrero,sizeof(obrero),1,temporal);
fread(&obrero,sizeof(obrero),1,P);
}

fclose(P);
fclose(temporal);
remove("prob4.txt");
rename("temporal.txt","prob4.txt");

cout << "\n\n\n\rArchivo compactado !!!";


cout << "\n\r<<< Oprima cualquier tecla para continuar >>>";
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
using namespace std;

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.";

cout << "\n\n\n\r Seleccione su opcion ---> ";


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)
{
cout<<"ERROR: El archivo no existe";
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)
{
cout << "\n\n\n\rRegistro duplicado !!!";
fclose(H);
getch();
return;
}
fread(&articulo,sizeof(articulo),1,H);
}

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)
{
cout << "\n\n\n\rNo existe el archivo !!!";
getch();
return;
}

cout << "\n\n\n\rNumero del articulo "; cin>>num;

fread(&articulo,sizeof(articulo),1,H);

while(!feof(H))
{
if(articulo.numero==num)
{
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\rDescripcion: "; cin>>articulo.descripcion;
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);
fwrite(&articulo,sizeof(articulo),1,H);

fclose(H);
cout << "\n\n\rRegistro modificado.";
getch();
return;
}
fread(&articulo,sizeof(articulo),1,H);
}
cout << "\n\rNo se encuentra ese registro !!!";
fclose(H);
getch();
return;
}
//----------------------------------------------------------------
void eliminar()
{
int num;
char op;
system("cls");

cout << "\n\rEliminar un Articulo";


H=fopen("articulo.txt","rb+");

if(H==NULL)
{ cout << "\n\n\n\rNo existe el archivo.";
getch();
return;
}
cout << "\n\n\n\rNumero del Articulo : "; cin>>num;

fread(&articulo,sizeof(articulo),1,H);

while(!feof(H))
{
if(articulo.numero==num)
{
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<<" $";
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) ---> ";
op=toupper(getche());
}while(op!='S' && op!='N');

if(op=='S')
{
fseek(H,ftell(H)-sizeof(articulo),SEEK_SET);
fwrite(&articulo,sizeof(articulo),1,H);
cout << "\n\n\n\rRegistro eliminado !!!";
}

fclose(H);
getch();
return;
}
fread(&articulo,sizeof(articulo),1,H);
}
cout << "\n\rNo se encuentra ese registro !!!";
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)
{
cout << "\n\n\n\rNo existe el archivo !!!";
getch();
return;
}

cout <<
"\n\r"<<setw(10)<<"Numero"<<setw(15)<<"Articulo"<<setw(15)<<"P.anterior"<<setw(15)<<"P.act
ual"<<setw(15)<<"%inflacion";
cout << "\n\r------------------------------------------------------------------------
";
fread(&articulo,sizeof(articulo),1,H);

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<<" %";
}
fread(&articulo,sizeof(articulo),1,H);
}

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>
using namespace std;
#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);
}
fread(&a,sizeof(a),1,f);
while(!feof(f))
{if(a.cod==codigo)
{cout<<"Codigo duplicado !!!!!"<<endl;
fclose(f);
getche();
exit(1);
}
fread(&a,sizeof(a),1,f);
}
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;
fwrite(&a,sizeof(a),1,f);
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)
{cout<<"No existe el archivo "<<endl;
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;
fread(&a,sizeof(a),1,f);
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;
fread(&a,sizeof(a),1,f);

}
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);
f=fopen("E:\\sueldo.dat","rb");
if(f==NULL)
{cout<<"No existe el archivo "<<endl;
getche();
exit (0);
}
fread(&a,sizeof(a),1,f);
while(!feof(f))
{if(strcmp(a.nom,nomb)==0)
{e=1;
mostrar1();

}
fread(&a,sizeof(a),1,f);
}
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;
f=fopen("E:\\sueldo.dat","rb");
if(f==NULL)
{cout<<"No existe el archivo "<<endl;
getche();
exit (0);
}
fread(&a,sizeof(a),1,f);
while(!feof(f))
{if(a.cod==codigo)
{e=1;
mostrar1();

}
fread(&a,sizeof(a),1,f);
}
if(e==0)
cout<<"el registro no esta registrdo"<<endl;
getche();
fclose(f);
}
//-------------------------------------------------
void ordenaalfabetico()
{int i,j,c;
c=0;
f=fopen("E:\\sueldo.dat","rb");
if(f==NULL)
{cout<<"No existe el archivo "<<endl;
getche();
exit (0);
}
fread(&a,sizeof(a),1,f);
while(!feof(f))
{reg[c]=a;
c=c+1;
fread(&a,sizeof(a),1,f);
}
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;
f=fopen("E:\\sueldo.dat","rb");
if(f==NULL)
{cout<<"No existe el archivo "<<endl;
getche();
exit (0);
}
fread(&a,sizeof(a),1,f);
while(!feof(f))
{reg[c]=a;
c=c+1;
fread(&a,sizeof(a),1,f);
}
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;
}