¡Una pregunta de programación!
#include "stdio.h" /*Función de E/S*/
#include "stdlib.h" /*función de biblioteca estándar*/
#include "string.h"/*Función de cadena*/
#include "ctype.h" /*Función de operación de caracteres*/
#define M 50 /*Definir constante Representa el número de registros*/
typedef struct /*definir estructura de datos*/
{
char name[20] /*name*/
char unidades[30]; /*unidades*/
char tele[10] /*teléfono*/
}DIRECCIÓN;
/******El siguiente es el prototipo de función*******/
int enter(ADDRESS t[] /*Input record*/
búsqueda vacía(DIRECCIÓN t[], int n /*Buscar registros mostrados por nombre*/
int eliminar(DIRECCIÓN t[], int n); /*Eliminar registro*/
int add(DIRECCIÓN t[], int n); /*Insertar registro*/
void save(DIRECCIÓN t[], int n); /*Guardar registros como archivos*/
int load(DIRECCIÓN t[] /*Leer registros de archivos*/
void display(ADDRESS t[]); /*Buscar registros de visualización por número de serie*/
void sort(ADDRESS t[], int n /*Ordenar por nombre*/
void qseek(ADDRESS t[], int n); /*Buscar registros rápidamente*/
void copy() /*Copia de archivo*/
int find(DIRECCIÓN t[], int n, char *s); p>int menu_select (); /*Función del menú principal*/
/******Se inicia la función principal*******/
main()
{
int i;
DIRECCIÓN adr[M]; /*Definir matriz de estructura*/
int longitud; longitud del registro* /
clrscr(); /*Borrar pantalla*/
for(;;)/*Bucle infinito*/
{
switch(menu_select()) /*Llama a la función del menú principal y devuelve el número entero como condición para la declaración de cambio*/
{
caso 0: longitud= enter(adr); break ;/*Ingresar registros*/
caso 1: list(adr, length /*Mostrar todos los registros*/
caso 2: sea);
rch(adr, longitud); /*Buscar registro*/
caso 3: longitud=eliminar(adr, longitud) /*Eliminar registro*/
4: longitud=add(dirección, longitud); romper /*insertar registro*/
caso 5: guardar(dirección, longitud) /*guardar archivo*/
caso 7: mostrar(adr); p > caso 8: sort(adr, longitud); /*Ordenar por nombre*/
caso 9: qseek(adr, longitud) /*Buscar registros rápidamente*/
caso 10: copiar(); break; /*Copiar archivo*/
caso 11: salida(0); /*Si el valor de retorno es 11, el programa finaliza*/
}
}
}
/*Función de menú, el valor de retorno de la función es un número entero que representa el elemento de menú seleccionado*/
menu_select()
{
char s[80];
int c
gotoxy(1; , 25); /*Establezca el cursor en la línea 25, columna 1*/
printf("presione cualquier tecla para ingresar al menú...\n"); /
getch(); /*Leer cualquier carácter*/
clrscr(); /*Borrar la pantalla*/
gotoxy(1, 1) ;
printf("************************MENÚ*************** **** ***\n\n");
printf(" 0. Ingrese el registro\n");
printf(" 1. Enumere el archivo\n ");
printf(" 2. Buscar registro por nombre\n");
printf(" 3. Eliminar un registro\n");
printf(" 4. agregar registro \n");
printf(" 5. Guardar el archivo\n"); ");
printf(" 7. mostrar registro en el pedido\n");
printf("
8. ordenar para crear un archivo nuevo\n");
printf(" 9. Registro de búsqueda rápida\n");
printf(" 10. copiar el archivo a un archivo nuevo \n");
printf(" 11. Salir\n");
printf("***************** ***** ****************************\n");
hacer{
printf("\n Ingrese su elección(0~11):"); /*Solicitar opciones de entrada*/
scanf("s", s /*Ingrese selecciones* /
c=atoi(s); /*Convertir la cadena de entrada en un número entero*/
} while(clt;0||cgt;11); No volver a ingresar entre 0 y 11*/
return c; /*Volver a la selección, el programa principal llama a la función correspondiente según el número*/
}
/***Registro de entrada, el parámetro formal es una matriz de estructura, el tipo de retorno del valor de la función es un número entero que representa la longitud del registro*/
int enter(ADDRESS t[])
{
int i, n;
char *s;
clrscr() /*borrar pantalla*/
printf( "\npor favor ingrese num \n"); /*Mensaje rápido*/
scanf("d",amp;n); /*Ingrese número de registro*/
printf( "por favor ingrese el registro \n"); /*Solicitar el registro de entrada*/
printf("nombre del teléfono de la unidad\n");
printf ("------ ------------------------------------------ \n");
for(i=0;ilt;n;i)
{
scanf("sss",t[i]. nombre,t[i].units , t[i].tele /*Registro de entrada*/
printf("-----------------); -------- ---------------------\n");
}
regresar n; /*Devuelve el número de registros */
}
/*Mostrar registros, los parámetros son la matriz de registros y el número de registros*/
lista vacía(DIRECCIÓN t[], int n)
{
int i
clrscr()
printf( "\n\n******* ************DIRECCIÓN******************\n");
printf("nombre
teléfono de la unidad\n");
printf("--------------------------------- ---------------\n");
for(i=0; ilt; n; i )
printf("- 20s-30s-10s\n", t[i].nombre, t[i].unidades, t[i].tele);
if((i 1)10==0) / *Juzga si la salida alcanza los 10 registros*/
{
printf("Presiona cualquier tecla para continuar...\n"); /*Mensaje rápido*/
getch(); /*Presione cualquier tecla para continuar*/
}
printf("**************** ****** *******fin************************\n");
}
/*Registro de búsqueda*/
búsqueda vacía(DIRECCIÓN t[], int n)
{
char s[20] ; /*Guardar la cadena de nombre a buscar */
int i; /*Guardar el número de serie del nodo encontrado*/
clrscr(); */
printf(" busque nombre\n");
scanf("s", s /*Ingrese el nombre que desea encontrar*/
);i=find(t, n, s); /*Llama a la función de búsqueda y obtiene un número entero*/
if(igt;n-1) /*Si el valor del número entero i es mayor que n-1, significa que no se encuentra*/
printf ("no encontrado\n");
else
print(t[ i]); /* Encontrado, llame a la función de visualización para mostrar el registro*/
}
/*Mostrar un registro específico*/
void print (DIRECCIÓN temporal)
{
clrscr();
printf("\n\n*************** *************************** *******\n");
printf("nombre teléfono de la unidad\n");
printf("---------- ----------------------- -----------\n");
printf("-20s-30s-10s\n", temp.nombre, temp.unidades, temp.tele);
printf("*************** ********end****************** ******\n");
}
/*Función de búsqueda, los parámetros son matriz de registros, número de registros y nombres */
int buscar(DIRECCIÓN t[], int n, char *s)
p>
{
int i;
for(i=0; ilt; n; i)/*Empieza desde el primer registro hasta el último*/< / p>
{
if(strcmp(s,t[i].name)==0) /*Si el nombre en el registro y el nombre a comparar son iguales*/
return i; /*Si son iguales, se devolverá el número de subíndice del registro y el programa finalizará antes de tiempo*/
}
return i ; /*Devuelve el valor de i*/
}
/*Eliminar función, los parámetros son la matriz de registros y el número de registros*/
int eliminar(DIRECCIÓN t[], int n)
{
char s[20] /*Nombre del registro que se eliminará*/
int ch=0;
int i, j ;
printf("por favor elimine el nombre\n"); /*Mensaje rápido*/
scanf(" s", s); /*Ingrese el nombre*/
i=find(t, n, s); /*Llame a la función de búsqueda*/
if(igt;n -1) /*Si igt;n-1 excede la longitud de la matriz */
printf("no encontrado no eliminado\n"); */
else
{
print(t[i] /*Llame a la función de salida para mostrar la información del registro*/
printf("¿Estás seguro de eliminarlo?(1/0)\n"); /*Confirma si deseas eliminarlo*/
scanf("d", amp; ch /*Enter); un número entero 0 o 1*/
if(ch==1) /*Si el número entero confirmado para ser eliminado es 1*/
{
for (j=i 1; jlt; n; j) /*Elimine el registro y los registros posteriores reales avanzarán* /
{
strcpy(t[j- 1].name, t[j].name); /*Copiar el nombre del siguiente registro al anterior*/
strcpy(t[j-1].units, t[j] .units); /*Copiar la unidad del siguiente registro al anterior*/
strcpy(t[ j-1].tele, t[j].tele /*Copiar el teléfono); número del registro siguiente al anterior*/
}
n-- /* Disminuir el número de registros en 1*/
}
}
return n; /*Devuelve el número de registros*/
}
/*Insertar función de registro, los parámetros son matriz de estructura y número de registro*/
int add(ADDRESS t[], int n)/*Insertar función, los parámetros son matriz de estructura y número de registro Número*/
{
DIRECCIÓN temp; /*Información del registro recién insertado*/
int i, j;
char s [20
]; /*Determine qué registro insertar antes*/
printf("ingrese el registro\n");
printf("********** ** ************************************\n");
printf("nombre de la unidad teléfono\n");
printf("----------------------------- ---------------------\n");
scanf("sss", temp.nombre, temp.units, temp.tele ); /*Ingresar información de inserción*/
printf("-------------------------------) --- ------------------\n");
printf("ingrese el nombre de ubicación \n");
scanf( "s", s); /*Ingrese el nombre en la posición de inserción*/
i=find(t, n, s); /*Llame a buscar para determinar la posición de inserción* /
for(j=n-1;jgt;=i;j--) /*Retroceder una línea comenzando desde el último nodo*/
{
strcpy(t [j 1].name, t[j].name); /*Copiar el nombre del registro actual al siguiente*/
strcpy(t[j 1] .units, t[j].units ); /*La unidad del registro actual se copia al siguiente*/
strcpy(t[j 1].tele, t[j].tele ); /*El número de teléfono del registro actual se copia al siguiente* /
}
strcpy(t[i].name, temp.name /*); Copie el nombre del registro recién insertado en la posición i-ésima*/
strcpy(t[i].units, temp.units /*Copie la unidad del registro recién insertado en la i); -ésima posición*/
strcpy(t[i].tele, temp .tele /*Copie el número de teléfono del registro recién insertado en la i-ésima posición*/
<); p> n; /*Agregar 1 al número de registros*/return n /*Devolver número de registros*/
}
/* Función guardar, los parámetros son la matriz de estructura y el número de registros*/
void save(ADDRESS t[], int n)
{
int i;
ARCHIVO *fp; /*Puntero al archivo*/
if((fp =fopen("record.txt", "wb"))==NULL) / *Abra el archivo y determine si la apertura es normal*/
{
printf("can not open file\n");
exit(1); /*Salir*/
}
printf("\nGuardando archivo\n"); /*Información de solicitud de salida*/
fpr
intf(fp, "d", n); /*Escribe el número de registros en el archivo*/
fprintf(fp, "\r\n"); archivo*/
for(i=0;ilt;n;i)
{
fprintf(fp, "-20s-30s-10s", t[i ].name, t[i].units, t[i].tele); /*Escribir registro en formato*/
fprintf(fp, "\r\n"); *Los símbolos de línea de ajuste se escriben en el archivo*/
}
fclose(fp); /*Cerrar el archivo*/
printf("** **guardado exitoso** *\n"); /*Mostrar guardado exitoso*/
}
/*Función de lectura, el parámetro es una matriz de estructura*/
int load (DIRECCIÓN t[])
{
int i, n;
ARCHIVO *fp /*Puntero al archivo*/
if((fp=fopen("record.txt", "rb"))==NULL)/*Abrir el archivo*/
{
printf("no se puede abrir el archivo\n"); /*No se puede abrir*/
exit(1 /*Salir*/
}
for(i=0; ilt; n; i)
fscanf( fp, "20s30s10s", t[i].name, t[i].units, t[i].tele /*Leer registros según formato*/
fclose(fp); *Cerrar el archivo*/
printf("¡¡Has leído correctamente los datos del archivo!!!\n"); /*Mostrar guardado exitoso*/
return n; Devuelve el número de registros*/
}
/*Mostrar funciones de registro por número de serie*/
visualización nula(DIRECCIÓN t[])
{
int id, n;
ARCHIVO *fp; /*Puntero al archivo*/
if((fp=fopen(" record.txt", "rb") )==NULL) /*Abrir archivo*/
{
printf("no se puede abrir el archivo\n"); /*No se puede open file*/
exit(1); /*Salir*/
}
printf("Ingrese el número de pedido...\n"); /*Mostrar información*/
scanf("d", amp; id /*Ingrese el número de serie*/
fscanf(fp, "d", amp; n); /*Leer el número de registros del archivo* /
if(idgt;=0amp;amp;idlt;n) /*Juzgar si el número de serie está dentro del rango de registros*/
{
fseek(fp,(id-1)*s
izeof(ADDRESS), 1); /*Mover el puntero del archivo a la posición del registro*/
print(t[id]); >
printf("\r\n");
}
else
printf("¡¡¡no hay registro de número d!!!\n " , id) ; /*Mostrar información si el número de serie no es razonable*/
fclose(fp); /*Cerrar el archivo*/
}
/*Función de clasificación, parámetros Es la matriz de estructura y el número de registros*/
void sort(ADDRESS t[], int n)
{
int i, j, flag;
DIRECCIÓN temp; /*Las variables temporales se utilizan para intercambiar datos*/
for(i=0; ilt; n; i)
{
flag=0; /*Establece el indicador para determinar si se ha producido un intercambio*/
for(j=0;jlt;n-1; j)
if((strcmp (t[j].name, t[j 1].name))gt; 0) /*Comparar tallas*/
{
flag=1;
strcpy(temp.name, t[j].name); /*Intercambiar registros*/
strcpy(temp.units, t [j].units);
strcpy(temp.tele, t[j].tele);
strcpy(t[j].nombre, t[j 1]. nombre);
strcpy(t [j].units, t[j 1].units);
strcpy(t[j].tele, t[j 1]. tele);
strcpy(t [j 1].nombre, temp.nombre);
strcpy(t[j 1].units, temp.units);
strcpy(t[j 1].tele , temp.tele);
}
if(flag==0)break /*Si la bandera es 0; , significa que no se ha producido el final del ciclo de intercambio*/
}
printf("sort sucess!!!\n"); /*Mostrar clasificación exitosa*/
}
/*Búsqueda rápida, los parámetros son la matriz de estructura y el número de registros*/
void qseek(ADDRESS t[], int n )
{
char s[20];
int l, r, m;
printf("\nPor favor, ordene antes qseek!\n"); /*Preguntar para confirmar si los registros se han ordenado antes de realizar la búsqueda*/
printf("Ingrese el nombre para qseek\n"); /*Pedir entrada*/
scanf("
s", s); /*Ingrese el nombre a encontrar*/
l=0; r=n-1; /*Establezca los valores iniciales de los límites izquierdo y derecho*/
while(llt;=r) /*Cuando el límite izquierdo lt;=límite derecho*/
{
m=(l r)/2; *Calcular la posición media */
if(strcmp(t[m].name, s)==0) /*Comparar con el campo de nombre del nodo intermedio para determinar si son iguales*/
{
print(t[m]); /*Si es igual, llame a la función de impresión para mostrar la información del registro*/
return; Retorno*/
}
if(strcmp(t[m].name, s)lt; 0) /*Si el nodo del medio es pequeño*/
l=m 1; /*Modificar el límite izquierdo */
else
r=m-1; /*De lo contrario, el nodo medio es grande, modificar el límite derecho */
}
if(lgt; r) /*Si el borde izquierdo es más grande que el borde derecho*/
printf("no encontrado\ n"); /*Pantalla no encontrada*/
}
/*Copiar archivo*/
copia nula()
{
char outfile[20]; /*Nombre del archivo de destino*/
int i, n;
DIRECCIÓN temp[M]; variables*/
ARCHIVO *sfp, *tfp; / *Definir puntero al archivo*/
clrscr() /*Borrar pantalla*/
if ((sfp=fopen("record.txt", "rb")) ==NULL) /*Abrir el archivo de registro*/
{
printf("no se puede abrir file\n"); /*Muestra la información del archivo que no se puede abrir*/
exit(1); /*Salir*/
}
printf("Ingrese el nombre del archivo de salida, por ejemplo c:\\f1\\te.txt:\ n"); /*Mensaje de solicitud*/
scanf("s", archivo de salida); el nombre del archivo de destino*/
if((tfp=fopen(outfile, "wb"))==NULL) /*Abrir el archivo de destino*/
{
printf("no se puede abrir el archivo\n"); /*Mostrar el mensaje de que el archivo no se puede abrir */
exit(1 /*Salir*/
fscanf(sfp, "d", amp; n); /*Leer número de registros del archivo de salida*/
fprintf(tfp, "d", n); /*Número de archivos de destino escritos*/
fprintf(tfp, "\r\n" ); /*Escribir carácter de nueva línea*/
for(i=0;ilt; n;i)
{
fscanf(sfp, "2
0s30s10s\n", temp[i].name, temp[i].units,
temp[i].tele); /*Leer el registro*/
fprintf( tfp, "-20s-30s-10s\n", temp[i].nombre,
temp[i].units, temp[i].tele /*Escribir registro*/< / p>
fprintf(tfp, "\r\n"); /*Escribir carácter de nueva línea*/
}
fclose(sfp); */
fclose(tfp); /*Cerrar el archivo de destino*/
printf("¡¡¡Has copiado el archivo correctamente!!!\n"); */
}