Código fuente de cambio de página
/* * * * *Archivo de encabezado (.
h)* * * * * * * */
#include "stdio.h" /*Función de E/S*/
# include "bios.h" /*ROM Funciones básicas de entrada y salida*/
#include "dos.h" /*función de interfaz dos*/
#include "conio. h" /*función de operación de pantalla*/< / p>
#include "stdlib.h" /*Otros comentarios*/
#include "string.h" /*Funciones de cadena*/
#include "mem .h" /*Función de operación de memoria*/
#include "ctype.h" /*Función de operación de caracteres*/
#include "alloc.h" /*Asignación dinámica de direcciones Función*/
/* * * *Definición de variable* * * * */
Typedef struct z1 /*Definir estructura de datos*/
{
Nombre del personaje[11];/*Número*/
nombre del personaje[15];/*Nombre*/
Jbgz flotante/*Salario básico*/
Deducción flotante; /*deducción*/
Yfgz flotante/*salario a pagar*/
Agua de oro flotante /*impuesto*/
Flotante sfgz/*salario real*/
struct z 1 * anterior /*puntero precursor*/
struct z 1 * next /*puntero posterior*/
p>}Salario; /*Nombre del tipo de estructura*/
struct z 1 * Primero; /*Puntero de encabezado de lista doblemente enlazado*/
struct z 1 * Último; / *Puntero de cola de lista doblemente enlazada*/
/* * * * * *Prototipo de función* * * * * * * *
void init() /*Inicialización* /
void create();/*Crear una lista enlazada*/
void calc();/*Calcular salarios a pagar*/
void delete( );/* Eliminar*/
void search() /*Buscar*/
void save() /*Guardar archivo*/
Vacío load(); /*Leer archivo*/
void computer(); /*Calcular el número de facturas requeridas*/
void insert() /*Insertar*/
void append(); /*Agregar*/
void copy(); /*Copiar archivos*/
void sort() /*Ordenar* /
void index();/*index*/
void total();/*número total por categoría*/
void list(); / *Mostrar todos los datos*/
Impresión nula (salario* p); /*Generar un solo registro*/
Visualización nula (/*Mostrar elemento por elemento a voluntad). */
Fax de punto flotante (punto flotante x); /*Calcular impuesto*/
int menu _ select() /*Menú principal*/
>/* * * * * *Se inicia la función principal* * * * * * * *
main()
{
int I;
clr SCR();
for(;;)
{
Interruptor
h(menu_select()) /*Llamar a la función de menú para devolver un valor entero*/
{
Caso 0: init() /*Inicialización*/
Caso 1: create(); break /*Ingresar datos para crear una lista doblemente enlazada*/
Caso 2: list() /*Mostrar todos los datos*/
Caso 3: display(); break /*Visualización única*/
Caso 4: calc(); break /*Calcular salario real*/
Caso 5: Buscar(); descanso; /*Buscar datos de información del empleado*/
Caso 6: eliminar(); /*Eliminar registro*/
Caso 7: insert(); Romper; /*Insertar registro*/
Caso 8: append(); Romper /*Agregar registro*/
Caso 9: guardar(); /*Guardar archivo */
Caso 10: cargar(); /*Leer archivo*/
Caso 11: copiar() /*Copiar archivo*/
Caso 12: sort(); Break; /* Ordenar por salario real en orden ascendente*/
Caso 13: Computer(); */
Caso 14: Index(); Descanso; /*Número total por departamento*/
Caso 16: Salir(0);/*Salir*/
}
}
}
/* Función de menú, el valor de retorno es un número entero que representa el elemento de menú seleccionado*/
menu_select()
{
Char *f[] = {/*Matriz de cadenas del menú de definición*/
"* * * * * * * * * * * * * * * *Menú* * * * * * * * * * * *", /* Fila de título del menú* /
"0.init list", /*Inicializar la lista doblemente enlazada*/
"1.Input list", /*Ingresar datos para crear una lista doblemente enlazada*/
"2. Listar todo\n ", /*Mostrar todos los registros*/
"3. Mostrar registros paso a paso", /*Mostrar uno solo record*/
"4.Calc el salario ", /*Calcular el salario real*/
"5. Buscar registros por nombre", /*Buscar registros*/
"6. Eliminar registros" , /*Eliminar registros*/
"7. Insertar registros en la lista", /*Insertar registros*/
"8 . Agregar registros al archivo", /*Agregar registro*/
"9. Guardar datos en el archivo", /*Guardar archivo*/
"10. ", /*Leer archivo*/
"11. Copiar archivos a archivos nuevos", /*Copiar archivos*/
"12. Ordenar por sfgz", /* Ordenar *. /
"13.ComputerTicketNumber ", /*Calcular el número de cara requerido*/
"14.Numerical index",/* index */
" 15.Cantidad total" , /*Total por categoría*/
" 16. Salir" }; /*Salir*/
char s[80];
int I;
int key = 0; /*Registra el valor de la tecla presionada*/
int c = 0;
gotoxy(1, 25 );/ *Mover el cursor*/
printf("Presione cualquier tecla para ingresar al menú...\n"
); /*Presiona cualquier tecla para ingresar al menú principal*/
getch();
clr SCR() /*Borrar la pantalla*/
textbackground(blue); /*Establece el color de fondo en azul*/
gotoxy(10, 2). ) ;
patch(0x da);/*Imprimir el borde de la esquina superior izquierda┏ */
for(I = 1;i lt44;i)
patch( 0x C4);/*Imprime la línea horizontal del borde superior*/
patch(0x BF);/*Imprime el borde de la esquina superior derecha ┓ */
for( I = 3; I lt22; I )/*Salida de líneas verticales izquierda y derecha*/
{
gotoxy(10, I; putch(0x B3); >
gotoxy(54, I ); putch(0x B3);
}
gotoxy(10, 22); putch(0xc 0); borde de la esquina izquierda┗ */
for(I = 1;ilt44;i)
patch(0x C4);/*Emite la línea horizontal del borde inferior*/
patch(0xd 9);/*Salida Borde de la esquina inferior derecha┛ */
Ventana (11, 3, 53, 21); /*Crea una ventana para mostrar el menú. la ventana está diseñada según el número de menús*/
clr SCR();/*Borrar pantalla*/
for(I = 0;ilt18;i)
{
gotoxy(10,I 1);
cprintf("s ", f[I]); /*Matriz de elementos del menú de salida*/
}
I = 1;
gotoxy(10, 2); /*Establece la opción predeterminada en el primer elemento*/
textbackground (verde claro) /*Establece el color de fondo en verde claro*/
cprintf("s ", f[1] /*Salida de elementos del menú, indicando*/
Y (key!=13) /*Cuando la tecla presionada no es la tecla Enter*/
{
while(BIOS key(1)= = 0);/*Consultar si se presiona una tecla*/
key = BIOS key(0); /*Volver a la siguiente tecla presionada en el teclado*/
Key=key amp0xff? Llaves y llaves. 0x ff: key gt; gt8; /*Juzga la tecla presionada*/
gotoxy(10, I 1);
textbackground (azul); to blue*/
cprintf("s ", f[I] /*Elemento del menú de salida*/
if(key==72) i=i= =1); ?17:I-1;/*Si presiona la tecla de cursor hacia arriba ↑, I disminuye en 1.
Si se ha movido a la primera fila, pasará a la última fila */
if(key==80)i=i==17?1:I 1;/*Si presiona hacia abajo Presione la tecla de cursor ↓ y agregaré 1. Si ha llegado a la última línea y luego baja, llegará a la primera línea*/
gotoxy(10, I 1);/*The siguiente elemento que mueve el cursor i */
textbackground(verde claro); /*Establece el color de fondo en verde claro*/
cprintf("s ", f[I] ); /*Elemento del menú de salida */
c = I-1 /*Asignar un valor entero que represente la opción del menú*/
}
textbackground (negro); /* Establecerá el color de fondo en negro */
Ventana (1, 1, 80, 25 /*Restaurará el tamaño original de la ventana*/
Regresar); to c; /*Volver a la opción de menú Valor entero*/
}
/*Función de inicialización*/
void inicialization()
{
Primero = NULL
Último = NULL
}
/*Ingrese datos y cree una lista doblemente enlazada* /
creación de vacío ( )
{
int x; *Registro de coordenadas de línea*/
int /*Registro el número de registros de entrada*/
int flag = 0 /*Fin de marca*/
Temperatura flotante /*Definir variables temporales*/
Información de salario*, * p; /*Definir variables temporales* /
If (first!=null)
init() /*Si el puntero principal es nulo, llame al función de inicialización*/
p =Primero ;/*Comenzar desde el puntero principal*/
for(;;)
{
if(bandera==1)
Romper /*Si bandera=1, finalice la entrada*/
I = 0;
x = 0; /*Determinar las coordenadas de la línea en movimiento*/
clr SCR();/*Borrar la pantalla*/
gotoxy(1, 3);
printf (" * * * * * * * * * * * * * * Miyako Guanli* * * * * * * * * * * *);/*Título de salida*/
gotoxy(1, 4 );
printf("-Enter @ end -"); /* Solicitar entrada @ End */
gotoxy(1,5);
printf(" |-| "); /*Emite la línea inicial de la tabla */
gotoxy(1, 6);
printf(" | no | nombre | jbgz | "); /* Títulos de los campos de salida, preste atención al número de espacios */
for(;;)
{
gotoxy(1, 7 x);
printf(" |-|-|-| " );/*Emite la línea horizontal de la tabla*/
info=(salario*)malloc( sizeof(salary));/*Solicitar espacio de grabación*/
If (! Información)
{
printf("\nMemoria insuficiente"); /*Si no hay espacio, genera información de desbordamiento de memoria*/
Salir (0 ) ;/*Salir del programa*/
}
Información - gt; next = NULL/*El nodo sucesor del nuevo nodo está vacío*/
Información - gt ; Prior = vacío /* La tarea predecesora del nuevo nodo está vacía */<
/p>
gotoxy(1, 8 x); printf (" | "); /*La línea divisoria entre los datos de salida*/
gotoxy(12, 8 x); ");
gotoxy(29, 8 x); printf(" | ");
gotoxy(38, 8 x); printf(" | ");
gotoxy(38, 8 x); p>
gotoxy(2, 8 No más de 10*/
if(info- gt; no [0]=='@ ' )
{
flag = 1;
Break;
}/*El primer carácter del número es @End Entrada * /
gotoxy(13, 8 x);/*Mover el cursor al nombre de entrada Ubicación*/
Input(info-gt;name,14);/*Ingresar nombre y verificar que la longitud no exceda de 14*/
gotoxy(30,8x);/ *El cursor ingresa a la posición del salario básico*/
scanf("f", amptemp );/*Ingrese el salario básico en una variable temporal*/
Información - gt; jbgz = temp/* Distribución del salario básico*/
Información - kou Kuan = 0 ; /* La deducción inicial es 0.
Entrada */
Información - gt; sfgz = 0; /* El pago del salario inicial es 0, que se calcula al calcular el salario */
Información - gt; 0; /* El impuesto inicial es 0 y se calcula al calcular los salarios */
Información - gt; yfgz = 0 /* El salario inicial a pagar es 0 y se calcula al calcular los salarios */
Si (p==NULL)/*Si p está vacío, ingrese el primer nodo*/
{
Primero = Último = información/*Puntero de cabecera y puntero de cola*/
Primero - gt; a priori = NULL /*El predecesor del puntero de cabeza es NULL*/
Finalmente - gt next = NULL/*El sucesor el puntero del puntero de cola es NULL* /
}
De lo contrario /*Si el nodo insertado no es el primer nodo, insértelo antes del nodo principal*/
{
Información-gt; next = p; /*El nodo sucesor del nuevo nodo apunta al nodo principal original*/
Información-gt;prior=p- >prior;/*El predecesor del nuevo nodo apunta al nodo principal original El predecesor del nodo principal*/
p->; nuevo nodo*/
}
p = info/ *El nuevo nodo se convierte en el nodo P y el nodo principal temporal*/
Primero = info/* El nuevo nodo se convierte en el nodo principal*/
x = 2; /*Debido a la línea horizontal, Mueva el cursor hacia abajo dos líneas*/
gotoxy(1, 8 x );
i;/*Ingrese el número de registros más 1*/
Si (i9==0)
Romper /*Ingrese 9 registros; y entra en una nueva página*/
}
gotoxy(1, 8 x);
}
printf(" | -|-|-| "); /*Línea horizontal de salida*/
}
/*Función de entrada y verificación de cadena*/
Entrada (carácter *s, entero)
{
char p[255];
Hacer {
scanf("s ", p) ; /*Cadena de entrada*/
if(strlen(p)>count)printf( "\n¡Demasiado largo!\n ");/*Comprueba la longitud y vuelve a ingresar*/
} while(strlen(p)>count);
strcpy(s, p);/*Copiar la cadena de entrada a la cadena s*/
}
/*Mostrar la lista enlazada*/
Lista no válida()
{
int i=0, n /*Registra el número; de líneas de salida*/
Salario* p;*Definir el puntero móvil*/
clr SCR() /*Borrar la pantalla*/
p = first; /*Comienza desde el puntero principal*/
while(I 10 = = 0 amp; ampp! =NULL) /*El bucle externo controla los cambios de página*/
{
I = 0 /*Registra el número de líneas de salida en una página*/
printf(" \ n \ n \ n "); /*Ajustar tres líneas*/
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *salario* * * * * * * * * * * * * * * * * * * * *
* * * * * \ n "); /* Título de salida */
printf(" | nO | nombre | jbgz | kou Kuan | yfgz | Jinshui | sfgz | \ n "); /* Salida Título del campo */
printf(" |-|-|-|-|-|-|-|-| \ n " /*Línea horizontal de salida*/
Y (p!=NULL) /*Cuando p no está vacío*/
{
printf(" | -10s | -15s | 9.2f | 9.2f | 9.2f | 9.2f | 9.2f | \n ",
p->; no, p- gt; nombre, p- gt; jbgz, p- gt; Kou Kuan, p- gt; yfgz, p- gt; gold water, p- gt; sfgz);
p = p- gt; /* el puntero se mueve hacia atrás*/
i; las líneas aumentan Anterior 1 */
if(i10==0)
Romper /*Si 10 filas están llenas, salta del bucle interno*/
}
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * fin * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \n ");/*Imprimir la línea final de esta página*/
printf("Presione cualquier tecla para continuar...\ n ");
getch();/*Imprima una página y haga una pausa, presione cualquier tecla para continuar*/
}/* Regresar al bucle exterior y preparar la salida de la página siguiente*/
}
/*Registro de visualización único*/
Pantalla vacía()
{
int ch/*Carácter de opción de menú*/
Salario* p /*Definir puntero temporal*/
clr SCR(); /*Borrar la pantalla*/
p = primero; /*Comenzar desde el puntero principal*/
If(p==NULL ) /*El puntero está vacío, es decir, la lista vinculada está vacía, Función principal*/
{
printf("¡El registro está vacío! \ n "); /p>
Regresar;
}
Otros
{
Imprimir(p);/*Llamar a la función de salida para mostrar la información del nodo principal*/
for(;;)/ *Inicio del período*/
{
printf("\n\n0. Salida 1. Resumen preliminar 2. Siguiente3. Primero 4.
último \ n \ n ");
/*Elemento del menú salir salir tarea predecesora anterior siguiente tarea de seguimiento primero último último */
printf(" \ nSeleccione 0 ~ 4 : "); /*Opción de menú de solicitud 0~4*/
scanf("d ", ampch); /*Opción de menú de entrada 0~4*/
if(ch == 0)break; /*Si la opción es 0, salga*/
switch(ch) /* La declaración de cambio se juzga según el carácter de opción*/
{
caso 1: p=p->prior; if (p = = NULL)p = Primero; /* apunta al predecesor, ningún predecesor apunta al primero*/
Caso 2: p=p->Siguiente; if (p == NULL) p = Último; break /* apunta al sucesor, ningún sucesor apunta al último*/
Caso 3 : p = primero; roto; /* apunta al primer nodo */
Caso 4: p = último; /* apunta al último nodo*/
}
Imprimir (p); /*Llame a la función de salida para mostrar la información del nodo señalado por el puntero*/
}
}
}
/*Muestre la información del nodo señalado por el puntero*/
Impresión nula (salario*p)
{
If(p) /*Si el puntero no está vacío, muestra información*/
{
clr SCR() /*Borrar la pantalla*/
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *Salario* * * * * * * * * * * * * * * * * * * * * * * * * * * * \n ");/* Información del título de salida*/
printf(" | no | name | jbgz | kou Kuan | yfgz |金水 | sfgz | \ n "/*Título del campo de salida*/
); printf(" |-|-|-| -|-|-|-|-| \ n ");/*Línea divisoria de salida*/
printf(" | -10s | -15s | 9.2 f | 9.2f | 9.2f | 9.2f | 9.2f | \n ", p- gt; no, p- gt; nombre,
p->; jbgz, p- gt; p- gt; yfgz, p- gt; Jinshui, p-gt;sfgz);/*Información del nodo de salida*/
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * fin * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \n "); /*Marca final de salida*/
}
}
/*Calcular salario real*/
void calc()
{
int x; /*Coordenada de línea*/
int I = 0 /*Cantidad de registros*; /
Temperatura flotante; /*Deducción variable temporal*/
>Salario* p; /*Mover el puntero*/
clr SCR(); /*Borrar la pantalla*/
p = primero /*Comenzar desde el puntero principal* /
Y (p!=NULL) /*Cuando p no está vacío, es decir, cuando hay un registro, el bucle externo controla el cambio de página*/
{
x = 0;
clr SCR();
gotoxy(1,3);
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ");/*Título de salida */
gotoxy(1, 5);
printf(" |-| ");
gotoxy(1, 6); /* Salida debajo del título del campo */
printf(" | no | name | jbgz | kou Kuan | yfgz | Jinshui | sfgz | "
And (p); !=NULL) /* Cuando p no está vacío, es decir, hay un registro, el control del bucle interno procesará 9 elementos*/
{
gotoxy(1, 7 x);
printf(" |-|-|-|-|-|-|-| ");
gotoxy(1, 8 x); printf(" | ");
gotoxy(12, 8 x); printf (" | ");
gotoxy(29, 8 x); printf (" | ");
gotoxi(38, 8 x ); printf(" | ");
gotoxi(49, 8 x); 58, 8 x); printf(" | ");
gotoxi(67, 8 x); printf (" | "); printf(" | ");
gotoxy(2, 8 8 x);
printf("-15s ", p->; nombre); /*nombre de salida*/
gotoxy(30, 8 x);
printf(".2f ", p- gt; jbgz /*Salario básico de salida*/
gotoxy(39, 8 x);
scanf("f ", amptemp);/*Ingrese el monto de la deducción*/
p->; koukuan = temp/*Asignación del campo de deducción */
p->; yfgz = p- gt; jbgz-p- gt; deducción; /* Calcular salario a pagar = salario básico - deducción */
gotoxy(50, 8 x);
printf(".2f " , p- gt; yfgz); /*salarios de salida a pagar*/
gotoxy(59, 8 x);
p->; agua de oro = (p- gt; yfgz -1000) * Fax (p- gt; yfgz /* De lo contrario, el impuesto se calculará de acuerdo con la tasa impositiva */
<) p>printf (".2f ", p- gt; agua dorada); /* Aranceles de exportación */gotoxy(68, 8 x);
p->; = p-gt
;yfgz-p- gt;金水;/*Calcular salarios reales*/
printf("-8.2f ",p->;sfgz);/*Producir salarios reales*/
x = 2; /*Mover la coordenada de línea dos líneas hacia abajo*/
i; /*Agregar 1 al número de registros*/
if(i9==0 ) interrumpir /*Si el número de registros excede 9, el bucle interno saltará*/
p = p- gt /*El puntero se mueve hacia atrás, siguiente*/
}
gotoxy(1, 7 x);
printf(" |-|-|-|-|-|-|-|-| \ n " ); /*Fin de la línea de salida */
printf("Presione cualquier tecla para continuar...\ n ");
getch(); >}
}
/*Calcular la tasa impositiva en función del salario a pagar*/
Fax de punto flotante (punto flotante x)
{
Punto flotante f 1;
if(x lt; 1000)
Devuelve 0 /*Si es menor que 1000, devuelve 0*/
Cambiar ((int)(x /1000))
{
Caso 1: f 1 = 0,05; descanso /*1000~1999; 0,05*/
Caso 2: f 1 = 0,1; /*de 2000 a 2999, 0,1*/
Caso 3: f 1 = 0,15; ~3999, devuelve 0,15*/
Caso 4: f 1 = 0,2; /*4000~4999, devuelve 0,2*/
Predeterminado: f 1 = 0,3; /*excede 5000, devuelve 0.3*/
}
Devuelve f 1;
}
/*Calcula el número de cupones */
Equipo no válido()
{
Salario * p;
int i=0, a[7]=, t100, t50, t20, t10, t5, t2, t 1 ;/*Establece el número de cupones guardados en la matriz y las variables temporales*/
Flotante t /*Variable de transición, guarda el resto actual; salario*/
p = first; /* Alejar el puntero del puntero principal*/
Y (p!=NULL) /*Cuando p no es nulo*/
{
t 100 = (int)p->;sfgz/100;/*Calcular el número de piezas de 100 yuanes*/
a[0] = a[0] t 100;/*Acumular y ahorrar*/
t = p- sfgz-t 100 * 100 /*salario restante*/
T50; (int)(t/50); /*calcular el número de hojas de 50 yuanes* /
a[1]= a[1] T50 /*Acumular y guardar*/
<; p>t = t-T50 * 50; /*Salario restante*/t20 =(int)(t/20);/*Calcular el número de hojas de 20 yuanes*/
a[2]= a[2] t20;/*Acumular y ahorrar*/
t = t-t20 * 20 /*Salario restante*/
t 10; =(int)(t/10); /*Calcular el número de hojas de 10 yuanes*/
a[3]= a[3] t 10 /*Acumular y guardar*/
t = t-t 10 * 10; /*Salario restante*/
t5 =(int)(t/5);/*Calcular el número de hojas de 5 yuanes*/
a[4]= a[4] t5;/*Acumular y guardar*/<
/p>
t = t-t5 * 5; /*salario restante*/
T2 =(int)(t/2); /*calcular el número de hojas de 2 yuanes*/< / p>
a[5]= a[5] T2 /*Acumular y ahorrar*/
t = t-T2 * 2 /*Salario restante*/
t 1 =(int)(t);/*Calcular 1 yuan*/
a[6]= a[6] t 1;/*Acumular y guardar*/
p = p- gt; Next; /*Mover el puntero hacia atrás y procesar el siguiente registro*/
}
clr SCR(); /
printf(" \ n \ n \ n * * * * * * * * * * *número de billete* * * * * * * * * * * * * * \ n ");/ * Título de salida*/
printf("-100-50-20-10-5-2-1-\ n ");
/*Título de la hoja de trabajo de salida*/
for(I = 0; I lt7; i)
printf("5d ", a[I]); /*Importe el número requerido de hojas*/
printf(" \ n ");/*Salto de línea*/
}
/*Buscar registros por número*/
Salario*Buscar (char *No)
{
Salario* p; /*Definir puntero móvil*/
p = primero /*Comenzar desde el puntero inicial* /
While(p) /*Cuando p no está vacío*/
{
If (! strcmp (no, p- gt; none))
Devuelve p; /*La comparación es igual, la búsqueda es exitosa, el puntero*/
p = p- gt;*El puntero desigual se mueve hacia atrás*/
}
printf("\n" no encontrado);/*No encontrado*/
Devuelve NULL/*Devuelve puntero nulo*/
}