Ayúdame a encontrar el código fuente del programa~~~

/****** Archivo de encabezado (.h) ***********/

#include "stdio.h"/*Función de E/S**/

#include "stdio.h"/*Función de E/S**/ p>

#include "stdlib.h"/* Funciones de biblioteca estándar**/

#include "string.h"/*Funciones de cadena**/

# include "ctype.h"/* Función de operación de caracteres**/

#define M 50 /*Definir las constantes para ser grabado.

#include "ctype.h" /*Función de operación de caracteres**/

#define M 50 /*Definir las constantes a registrar.

#define M 50 /*Definir la constante que representa el número de registros**/

typedef struct /*Definir la estructura de datos**/

{

char name[20]; /*name**/ 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* *

void print(ADDRESS temp); /*Mostrar un registro**

int find(ADDRESS t[],int n,char *s); *Buscar función* *

int menu_select( ); /*Función del menú principal*/

/****** Función principal, inicio*******/

main()

{

int i

DIRECCIÓN adr[M] /* Definir matriz de estructura*/

int length=0; /* Guardar longitud del registro*/

clrscr(); /* Borrar pantalla*/

for(;;)/* Bucle infinito */

{

switch(menu_select()) /* Llame a la función del menú principal, el valor de retorno entero es la condición de la declaración de cambio*/

{

case 0.length=enter(adr);break; /* Registros de entrada*/

case 1:list(adr,length);break /* Mostrar todo; registros*/

caso 2:search(adr,length);break; /* Buscar registro*/

caso 3: record=delete(adr,length);break; *Eliminar registro**/

caso 4:length=add(adr,length);break; /*Insertar registro**/

case 5:save(adr,length) .break; /*Guardar el archivo */

caso 6:length=load(adr); break /*Por número de serie Mostrar registros*/

case 8:sort(adr,length).break /*Ordenar por nombre*/

case 9:qseek(adr; ,length);break; / *Buscar registros rápidamente*/

case 10:copy();break; /*Copiar archivos*/

case 11:exit(0); /*Si el valor de retorno es 11, el programa finaliza*/

}

}

}

}

/*Función de menú, esta La función devuelve un número entero que representa el elemento de menú seleccionado*/

menu_select()

{

char s[80] ;

int c;

gotoxy(1,25);/* Coloque el cursor en la línea 25, columna 1**

printf("presione cualquiera clave e

nter menu...\n");/*Solicitud de presionar cualquier tecla para continuar*/

getch(); /*Leer cualquier carácter*/

clrscr( ); /*Borrar pantalla*/

gotoxy(1,1);

printf("****************** ** MENÚ********** *************\n\n");

printf(" 0.Ingrese registro\n");

printf(" 1.Listar el archivo\n");

printf(" 2.Buscar registro por nombre\n"); " 3.Eliminar un registro\n");

printf(" 4.agregar registro\n");

printf(" 5.Guardar el archivo\n");

printf(" 6.Cargar el archivo\n").Cargar el archivo\n");

printf(" 7. mostrar registro en el pedido\n");

printf(" 8. ordenar para crear un nuevo archivo\n");

printf(" 9. Registro de búsqueda rápida\n"); " 10. copie el archivo en un archivo nuevo\n");

printf(" 10. " 10. copie el archivo en un archivo nuevo\n");

printf(" 11.Salir\n");

printf("********************************* **** ***************\n");

do{

printf("\n Introduzca su elección(0 ~11): "); /* Opciones de solicitud*/

scanf("%s",s); /* Selecciones de entrada*/

c=atoi(s); /* Convertirá la cadena de entrada a un número entero*/

} while(c<0||c>11); /* La selección está entre 0 y 11 sin entrada repetida*/

return c; /* Devuelve 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 y el tipo de retorno del valor de la función es Entero, lo que indica la longitud del registro*/

int enter(ADDRESS t[])

{

int i,n;

char *s;

clrscr(); /* Borrar pantalla*/

hacer{

printf("/n¿Cuántos números desea registrar? \Por favor, ingrese el número que desea:\n"); /*Mensaje rápido*/

scanf("%d",&n); *Ingrese el número de registros*/

if(n==0)

printf("¡el número no puede ser '0'! ¡Por favor vuelve a entrar! ");

} while(n==0);

printf("por favor ingrese el registro \n");/*Solicitar registro de entrada*/

printf("nombre

e\tunit\ttelefono\t\n");

printf("---------------------- --- --------------------\n");

for(i=0;i

{

scanf("%s%s%s",t[i].name,t[i].units,t[i].tele);/*Registro de entrada* /

printf("-----------¡Ok! ¡El registro ha sido grabado!------------\n");

}

printf("¡todo ha sido grabado!\n");

getch();

clrscr();

return n; /* devuelve el número de entradas de registro*/

}

/* Muestra el registro, los parámetros son la matriz de registros y el número de registro. entradas*/

lista vacía(DIRECCIÓN t[],int n)

{

int i

clrscr();

printf ("\n\n************************DIRECCIÓN****** ***** *******\n");

printf("nombre del teléfono de la unidad\n");

printf("---------- ------------- -----------------------\n");

si( n. =0)

si (n!=0)

for(i=0;i

{

printf("%-20s%- 30s%-10s\n",t[i].nombre,t[i].unidades,t[i].tele);

if( (i+1)%10==0) /* Determinar si la salida alcanza los 10 registros*/

{

printf("Presione cualquier tecla para continuar... (Presione cualquier para continuar...)") ; /* Mensaje rápido***

getch(); /* Presione cualquier tecla para continuar***

}

}

En caso contrario printf("¡no hay ningún registro!\n");

printf("*************** ******* ***fin *******************\n");

}

//*buscar registro**/

void search(DIRECCIÓN t[],int n)

{

char s[20]; la cadena de nombre que se buscará**/

int i;*contiene el número de serie del nodo que se buscará */

/*clrscr() */ / * borrar la pantalla */

printf("por favor busque nombre\n");

scanf("%s",s /* Ingrese el nombre a buscar* /

i=buscar( t,n,

s); /* Llama a la función de búsqueda y obtiene un número entero*/

if(i>n-1) /* Si el valor del número entero i es mayor que n-1, no se encuentra* /

printf("not found!\n");

else

print(t[i]); Llame a la función de visualización. para mostrar el registro*/

clrscr();

}

/* Mostrar un registro específico*/

void print( DIRECCIÓN temporal)

{

/* clrscr() */

printf("\n \n**********; ******** *******************************\n");

printf("nombre de la unidad teléfono\n")

printf("-------------------------- --- --------- ---------\n");

printf("%-20s%-30s%-10s\n",temp.name, temp.units,temp.tele);

printf("************************ fin****** *************** ******\n");

}

/* Función de búsqueda, los parámetros son la matriz de registros, el número de entradas de registros y el nombre s */

int find(ADDRESS t[],int n,char *s)

{

int i;

for(i=0;i

{

if(strcmp(s,t[i].name)==0) /* Si el nombre en el registro y el nombre a comparar son iguales*/

return /* If son iguales, se devolverá el número de subíndice del registro y el programa finalizará antes de tiempo*/

}

return i /* return i value*/

}

/* Función de eliminación, los parámetros son la matriz de registros y el número de entradas de registros*/

int delete(ADDRESS 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); /*Llamar a la función de búsqueda*/

if( i>n-1) /*If i>n-1 excede la longitud de la matriz*/

printf("no encontrado, no eliminado\n" /* Muestra que el registro que se va a eliminar no se encuentra**

else

{

print(t[i]); /* Llama a la función de salida para mostrar la información del registro*/

printf(" ¿Estás seguro de eliminarlo(1)? /0)\n"); /* Confirmar para eliminar el registro*/

scanf("%d",&ch); /*Ingrese el número entero 0 o 1 * /

if(ch==1) /*Si el número entero confirmado para ser eliminado es 1 */

{

for(j=i+1;j

{

strcpy(t[j-1].tele); /* Copiar int add(ADDRESS t[],int n)/* Insertar función, los parámetros son la matriz de estructura y el número de registros*/

{

DIRECCIÓN temp; /* Información del registro recién insertado*/

int i,j

char s[20]; *Confirma que quieres registros insertados*/

Esta función es una función que inserta registros en una matriz de estructura y el número de registros.

p>

printf("ingrese el registro\n");

printf("********************* ******************************\n");

printf("nombre de la unidad teléfono\n ") ;

printf("------------------------------------- -- -----------\n");

scanf("%s%s%s",temp.name,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 de la posición de inserción*/

i=find(t,n,s) ​​/* Llame a la búsqueda para determinar la posición de inserción*/

for( j=n-1;j>=i;j--) /* Retroceder una línea desde el último nodo*/

{

strcpy(t[ j+1].name,t[j].name); /* Copia el nombre del registro actual una línea hacia atrás*/

strcpy(t[j+). 1].units,t[j] .units); /* Copia la unidad del registro actual una línea hacia atrás*/

strcpy(t[j+1]. tele,t[j]. tele /* Copiar la tele del registro actual Copiar a la siguiente entrada*/

}

strcpy(t[j+1].

strcpy (t[i].name,temp.name ); /* Copia el nombre del registro recién insertado en la posición i-ésima*/

strcpy(t[i].units,temp.units ); /* Copiar la unidad del registro recién insertado a la posición i-ésima posición i*/

strcpy(t[i].tele,temp.tele /*Copiar el registro recién insertado); número de teléfono a la posición i-ésima*/

n++ ; /*Aumenta el número de registros en 1 */

return n /*Devuelve el número de registros*/

}

/*Agregar la unidad del registro recién insertado Copiar a la posición i-ésima*/

strcpy(t[i].

/* 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 de archivo*/

if((fp= fopen("record.txt", "wb")) ==NULL) /*Abra el archivo y confirme si se abrió correctamente**

{

printf("can not open file\n");/* no lo hizo open**

exit(1); /*Salir**

}

printf("\nGuardando archivo\n"); mensaje*/

fprintf(fp, "¡hay %d registros! ",n); /* Escribe el número de registros en el archivo */

fprintf(fp,

"\r\n"); /* Escribe el número de nuevas líneas en el archivo*/

for(i=0;i

{

fprintf(fp,"%-20s%-30s%-10s",t[i].name,t[i].units,t[i].tele);/*Registros de escritura formateados*/

fprintf( fp,"\r\n"); /*Escribe el número de nueva línea en el archivo*/

}

fclose(fp);/* Cerrar el archivo*/

printf("****guardado exitoso***\n" /* Mostrar guardado exitoso*/

}

//// Leer la función cuyo parámetro es la estructura array*/

int load(ADDRESS t[])

{

int i,n;

ARCHIVO *fp; /* Puntero de archivo*/

if((fp=fopen("record.txt", "rb"))==NULL)/* Abrir archivo * /

{

printf("no se puede abrir el archivo\n"); /* no se puede abrir el archivo\n"

exit(1); / * exit* *

}

fscanf(fp,"%d",&n /* Leer el número de registros*/

for(i); =0;i

fscanf(fp,"%20s%30s%10s",t[i].nombre,t[i].units,t[i].tele) ; /* Presione Formatear registro de lectura*/

fclose(fp); /* Cerrar el archivo*/

printf("¡¡¡Has leído correctamente los datos del archivo!!!!! \n") ; /* Mostrar guardado exitoso*/

return n; /* Devolver el número de registros*/

}

//* Mostrar la función de registro por número de serie* /

void display(ADDRESS t[])

{

int id,n

ARCHIVO *fp; /* puntero de archivo**/

if((fp=fopen("record.txt", "rb"))==NULL) /* Abrir archivo**/

{

printf("no se puede abrir el archivo\n"); /* No se puede abrir el archivo**/

p> exit(1 /* exit/);

}

printf("Ingrese el número de pedido...\n"); /* Mostrar información*/

scanf("%d",&id ); /* Ingrese el número de pedido */

fscanf(fp,"%d",&n /* Lea el número de registros del archivo*/

if(id); >=0&&id<n) /* Determinar si el número de secuencia está dentro del rango de registros*/

{

fseek(fp,(id-1)*sizeof(ADDRESS), 1); /* Mueve el puntero del archivo a la Posición del registro*/

print(t[id] /* Llama a la función de salida para mostrar el registro*/

printf); ("\r \n");

}

else

printf("no %d n

número de registro!!!!! \n ",id); /*Si el número de serie no tiene significado para mostrar información*/

fclose(fp); /*Cerrar el archivo*/

}

/* Función de clasificación con matriz de estructura de parámetros y número de registro*/

void sort(ADDRESS t[],int n)

{

int i,j,flag;

DIRECCIÓN temp;/* Variable temporal utilizada para intercambiar datos*/

for(i=0;i

{

flag=0; /* Establece el indicador para determinar si se produjo el intercambio*/

for(j=0;j

if((strcmp(t[j].nombre,t[j+1].nombre))>0)

if((strcmp(t[j]. nombre,t[j+1].nombre) >0) /*Comparar tamaño**

{

flag=1

strcpy(temp. nombre,t[j].nombre); /*Intercambiar registros**/

strcpy(temp.units,t[j].units); (temp.tele,t[j].tele);

strcpy(t[j].nombre,t[j+1].nombre);

strcpy(t[); j]. unidades,t[j+1].unidades);

strcpy(t[j].tele,t[j+1].tele 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 el indicador es 0, el ciclo finaliza y no se realiza ningún intercambio* /

}

printf("clasificación exitosa!! \n" /* Mostrar clasificación exitosa*/

}

/ * Utilice la matriz de estructura de parámetros y el número de registro para buscar rápidamente*/

void qseek(ADDRESS t[],int n)

{

char s[ 20] ;

int l,r,m;

printf("\n¡Por favor ordene antes de qseek! \n"); /* Solicitar confirmación de que los registros se han ordenado antes de realizar la búsqueda*/

printf("ingrese el nombre para qseek\n"); /* Solicitar entrada*/

scanf("%s",s ); /* Ingrese el nombre a encontrar*/

l=0;r=n-1 /* Establezca el valor inicial de la izquierda y límites derechos*/

while(l<=r) /* cuando límite izquierdo <= límite derecho*/

{

m=(l+r )/2; /* cálculo Posición media*/

if( strcmp(t[m].name,s)==0)/* Comparar con el campo de nombre del nodo medio para determinar si son iguales */

{

print(t[m]); /* Si es igual, llama a la función de impresión para mostrar la información del registro*/

return ; /* Regresar*/

> }

if(strcmp(t[m].name,s)<0)/* Si el nodo intermedio es pequeño*/

l=m+1; Modificar límite izquierdo*/

else

r=m-1; /* De lo contrario, el nodo medio es muy grande, modificar el límite derecho*/

}

if(l>r) /* Si el borde izquierdo es mayor que el borde derecho*/

printf("not found\n" /* Mostrar no encontrado); */

}

/* Copiar archivo*/

void copy()

{

char outfile[20]; /* Nombre del archivo de destino*

int i,n

DIRECCIÓN temp[M] /* Definir variables temporales*/

ARCHIVO *sfp,*tfp; /* Definir el puntero al archivo*/

clrscr();/* Limpiar la pantalla*/

if((sfp=fopen(" record.txt", "rb"))= =NULL) /*Abrir el archivo de registro**/

{

printf("no se puede abrir el archivo\n"); /*Muestra el mensaje de que el archivo no se puede abrir*/

exit(1 /*Salir**

}

printf("Ingrese el archivo de salida); nombre, por ejemplo c:\f1\te.txt：\n "); /*Mensaje rápido*/

scanf("%s",outfile); /*Ingrese 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 que el archivo no se puede abrir Mensaje*/

exit(1 /*exit

);