From c0fecc353677ef48f7af43421d717e26db0de2ec Mon Sep 17 00:00:00 2001 From: JNmeca Date: Wed, 16 Nov 2022 18:17:05 -0400 Subject: [PATCH] 16/11/2022 ; 6:15 PM --- .../Programas/Programa 8.1/Programa 8.1.c | 97 +++++++ .../Programas/Programa 8.10/Programa 8.10.c | 228 ++++++++++++++++ .../Programas/Programa 8.2/Programa 8.2.c | 107 ++++++++ .../Programas/Programa 8.3/Programa 8.3.c | 128 +++++++++ .../Programas/Programa 8.4/Programa 8.4.c | 108 ++++++++ .../Programas/Programa 8.5/Programa 8.5.c | 135 ++++++++++ .../Programas/Programa 8.6/Programa 8.6.c | 244 ++++++++++++++++++ .../Programas/Programa 8.7/Programa 8.7.c | 114 ++++++++ .../Programas/Programa 8.8/Programa 8.8.c | 150 +++++++++++ .../Programas/Programa 8.9/Programa 8.9.c | 162 ++++++++++++ 10 files changed, 1473 insertions(+) create mode 100644 8. Estructuras y uniones/Programas/Programa 8.1/Programa 8.1.c create mode 100644 8. Estructuras y uniones/Programas/Programa 8.10/Programa 8.10.c create mode 100644 8. Estructuras y uniones/Programas/Programa 8.2/Programa 8.2.c create mode 100644 8. Estructuras y uniones/Programas/Programa 8.3/Programa 8.3.c create mode 100644 8. Estructuras y uniones/Programas/Programa 8.4/Programa 8.4.c create mode 100644 8. Estructuras y uniones/Programas/Programa 8.5/Programa 8.5.c create mode 100644 8. Estructuras y uniones/Programas/Programa 8.6/Programa 8.6.c create mode 100644 8. Estructuras y uniones/Programas/Programa 8.7/Programa 8.7.c create mode 100644 8. Estructuras y uniones/Programas/Programa 8.8/Programa 8.8.c create mode 100644 8. Estructuras y uniones/Programas/Programa 8.9/Programa 8.9.c diff --git a/8. Estructuras y uniones/Programas/Programa 8.1/Programa 8.1.c b/8. Estructuras y uniones/Programas/Programa 8.1/Programa 8.1.c new file mode 100644 index 0000000..ad239ed --- /dev/null +++ b/8. Estructuras y uniones/Programas/Programa 8.1/Programa 8.1.c @@ -0,0 +1,97 @@ +#include +#include + +/* Estructuras-1. +El programa muestra la manera en que se declara una estructura, así como la +➥forma en que se tiene acceso a los campos de las variables de tipo estructura +➥tanto para asignación de valores como para lectura y escritura. */ + +struct alumno /* Declaración de la estructura. */ +{ + int matricula; + char nombre[20]; + char carrera[20]; /* Campos de la estructura. */ + float promedio; + char direccion[20]; +}; /* Observa que la declaración de una estructura termina con punto y +➥coma. */ + +void main(void) +{ + /* Observa que las variables de tipo estructura se declaran como cualquier otra + ➥variable. a1, a2 y a3 son variables de tipo estructura alumno. */ + + struct alumno a1 = { 120, "Maria", "Contabilidad", 8.9, "Queretaro" }, a2, a3; + /* Los campos de a1 reciben valores directamente. */ + + char nom[20], car[20], dir[20]; + int mat; + float pro; + + /* Los campos de a2 reciben valores por medio de una lectura. */ + printf("\nIngrese la matricula del alumno 2: "); + scanf("%d", &a2.matricula); + fflush(stdin); + + printf("Ingrese el nombre del alumno 2: "); + gets(a2.nombre); + + printf("Ingrese la carrera del alumno 2: "); + gets(a2.carrera); + + printf("Ingrese el promedio del alumno 2: "); + scanf("%f", &a2.promedio); + fflush(stdin); + + printf("Ingrese la direccion del alumno 2: "); + gets(a2.direccion); + /* Los campos de a3 reciben valores por medio de asignaciones. */ + + printf("\nIngrese la matricula del alumno 3: "); + scanf("%d", &mat); + a3.matricula = mat; + fflush(stdin); + + printf("Ingrese el nombre del alumno 3: "); + + gets(nom); + strcpy(a3.nombre, nom); + + printf("Ingrese la carrera del alumno 3: "); + gets(car); + strcpy(a3.carrera, car); + + printf("Ingrese el promedio del alumno 3: "); + scanf("%f", &pro); + a3.promedio = pro; + fflush(stdin); + + printf("Ingrese la direccion del alumno 3: "); + gets(dir); + strcpy(a3.direccion, dir); + /* Observe la forma en que se imprimen los campos de a1 y a2. */ + + printf("\nDatos del alumno 1\n"); + + printf("%d\n", a1.matricula); + puts(a1.nombre); + puts(a1.carrera); + + printf("%.2f\n", a1.promedio); + puts(a1.direccion); + + printf("\nDatos del alumno 2\n"); + + printf("%d\n", a2.matricula); + puts(a2.nombre); + puts(a2.carrera); + + printf("%.2f\n", a2.promedio); + puts(a2.direccion); + /* Observa otra forma de escribir los campos de la variable de tipo estructura + a3. */ + + printf("\nDatos del alumno 3\n"); + + printf("%d \t %s \t %s \t %.2f \t %s", a3.matricula, a3.nombre, a3.carrera, a3.promedio, a3.direccion); +} \ No newline at end of file diff --git a/8. Estructuras y uniones/Programas/Programa 8.10/Programa 8.10.c b/8. Estructuras y uniones/Programas/Programa 8.10/Programa 8.10.c new file mode 100644 index 0000000..943a5f9 --- /dev/null +++ b/8. Estructuras y uniones/Programas/Programa 8.10/Programa 8.10.c @@ -0,0 +1,228 @@ +#include +#include + +/* Vendedores. +El programa maneja información sobre las ventas que realizan los vendedores de +➥artículos domésticos de una importante empresa de la Ciudad de México. */ + +typedef struct /* Declaración de la estructura banco. */ +{ + char noba[10]; /* Nombre del banco. */ + char nucu[10]; /* Número de cuenta. */ +} banco; + +typedef union /* Declaración de la union fpago. */ +{ + banco che; /* Cheque. Campo de tipo estructura banco. */ + banco nomi; /* Cómina. Campo de tipo estructura banco. */ + char venta; /* Ventanilla. */ +} fpago; + +typedef struct /* Declaración de la estructura domicilio. */ +{ + char cnu[20]; /* Calle y número. */ + char col[20]; /* Colonia. */ + char cp[5]; /* Código Postal. */ + char ciu[15]; /* Ciudad. */ +} domicilio; + +typedef struct /* Declaración de la estructura vendedor. */ +{ + int num; /* Número de vendedor. */ + char nom[20]; /* Nombre del vendedor. */ + float ven[12]; /* Ventas del año. Arreglo unidimensional de tipo real. */ + domicilio domi; /* domi es de tipo estructura domicilio. */ + float sal; /* Salario mensual. */ + fpago pago; /* pago es de tipo unión fpago. */ + int cla; /* Clave forma de pago. */ +} vendedor; + +void Lectura(vendedor*, int); +void F1(vendedor*, int); +void F2(vendedor*, int); /* Prototipos de funciones. */ +void F3(vendedor*, int); +void F4(vendedor*, int); + +void main(void) +{ + vendedor VENDEDORES[100]; + /* Declaración del arreglo unidimensional de tipo estructura vendedor. */ + int TAM; + + do + { + printf("Ingrese el numero de vendedores: "); + scanf("%d", &TAM); + } while (TAM > 100 || TAM < 1); + /* Se verifica que el número de elementos del arreglo sea correcto. */ + + Lectura(VENDEDORES, TAM); + F1(VENDEDORES, TAM); + F2(VENDEDORES, TAM); + F3(VENDEDORES, TAM); + F4(VENDEDORES, TAM); + + printf("\n\tFIN DEL PROGRAMA"); +} + +void Lectura(vendedor A[], int T) +/* Esta función se utiliza para leer un arreglo unidimensional de tipo +➥estructura vendedor de T elementos. */ +{ + + int I, J; + + for (I = 0; I < T; I++) + { + printf("\n\tIngrese datos del vendedor %d", I + 1); + printf("\nNumero de vendedor: "); + scanf("%d", &A[I].num); + + printf("Nombre del vendedor : "); + fflush(stdin); + gets(A[I].nom); + + printf("Ventas del año: \n"); + + for (J = 0; J < 12; J++) + { + printf("\tMes %d: ", J + 1); + scanf("%f", &A[I].ven[J]); + } + + printf("Domicilio del vendedor: \n"); + printf("\tCalle y numero: "); + fflush(stdin); + gets(A[I].domi.cnu); + + printf("\tColonia: "); + fflush(stdin); + gets(A[I].domi.col); + + printf("\tCodigo Postal: "); + fflush(stdin); + gets(A[I].domi.cp); + + printf("\tCiudad: "); + fflush(stdin); + gets(A[I].domi.ciu); + + printf("Salario del vendedor: "); + scanf("%f", &A[I].sal); + + printf("Forma de Pago (Banco-1 Nomina-2 Ventanilla-3): "); + scanf("%d", &A[I].cla); + + switch (A[I].cla) + { + + case 1: { + printf("\tNombre del banco: "); + fflush(stdin); + gets(A[I].pago.che.noba); + + printf("\tNumero de cuenta: "); + fflush(stdin); + gets(A[I].pago.che.nucu); + } + break; + + case 2: { + printf("\tNombre del banco: "); + fflush(stdin); + gets(A[I].pago.nomi.noba); + + printf("\tNumero de cuenta: "); + fflush(stdin); + gets(A[I].pago.nomi.nucu); + } + break; + + case 3: A[I].pago.venta = 'S'; + break; + } + } +} + +void F1(vendedor A[], int T) +/* Esta función se utiliza para generar las ventas totales anuales de cada uno +➥de los vendedores de la empresa. */ +{ + int I, J; + float SUM; + + printf("\n\t\tVentas Totales de los Vendedores"); + + for (I = 0; I < T; I++) + { + printf("\nVendedor: %d", A[I].num); + + SUM = 0.0; + + for (J = 0; J < 12; J++) + SUM += A[I].ven[J]; + + printf("\nVentas: %.2f\n", SUM); + } +} + +void F2(vendedor A[], int T) +/* Esta función se utiliza para incrementar 5% el salario de todos aquellos +➥vendedores cuyas ventas anuales superaron $1,500,000. */ +{ + int I, J; + float SUM; + + printf("\n\t\tIncremento a los Vendedores con Ventas > 1,500,000$"); + + for (I = 0; I < T; I++) + { + SUM = 0.0; + for (J = 0; J < 12; J++) + SUM += A[I].ven[J]; + + if (SUM > 1500000.00) + { + A[I].sal = A[I].sal * 1.05; + printf("\nNumero de empleado: %d\nVentas: %.2f\nNuevo salario: %.2f", + A[I].num, SUM, A[I].sal); + } + } +} + +void F3(vendedor A[], int T) +/* Esta función se utiliza para generar un listado de todos aquellos +➥vendedores que en el año vendieron menos de $300,000. */ +{ + int I, J; + float SUM; + + printf("\n\t\tVendedores con Ventas < 300,000$"); + + for (I = 0; I < T; I++) + { + SUM = 0.0; + for (J = 0; J < 12; J++) + SUM += A[I].ven[J]; + + if (SUM < 300000.00) + printf("\nNumero de empleado: %d\nNombre: %s\nVentas: %.2f", A[I].num, + A[I].nom, SUM); + } +} + +void F4(vendedor A[], int T) +/* Esta función se usa para imprimir el número de empleado, el nombre del +➥banco y el número de cuenta de todos aquellos empleados a quienes se les +➥deposita su sueldo en cuenta de cheques. */ +{ + int I; + float SUM; + + printf("\n\t\tVendedores con Cuenta en el Banco"); + + for (I = 0; I < T; I++) + if (A[I].cla == 1) + printf("\nNumero de vendedor: %d\n Banco: %s\nCuenta: %s", A[I].num, + A[I].pago.che.noba, A[I].pago.che.nucu); +} \ No newline at end of file diff --git a/8. Estructuras y uniones/Programas/Programa 8.2/Programa 8.2.c b/8. Estructuras y uniones/Programas/Programa 8.2/Programa 8.2.c new file mode 100644 index 0000000..17a6a04 --- /dev/null +++ b/8. Estructuras y uniones/Programas/Programa 8.2/Programa 8.2.c @@ -0,0 +1,107 @@ +#include +#include +#include + +/* Estructuras-2. +El programa muestra la manera en que se declara una estructura, así como la +➥forma en que se tiene acceso a los campos de los apuntadores de tipo estructura +➥tanto para lectura como para escritura. Se utiliza además una función que +➥recibe como parámetro un apuntador de tipo estructura. */ + +struct alumno /* Declaración de la estructura. */ +{ + int matricula; + char nombre[20]; + char carrera[20]; /* Campos de la estructura alumno. */ + float promedio; + char direccion[20]; +}; + +void Lectura(struct alumno*); /* Prototipo de función. */ + +void main(void) +{ + struct alumno a0 = { 120, "Mara", "Contabilidad", 8.9, "Queretaro" }; + struct alumno* a3, * a4, * a5, a6; + /* Observa que las variables *a3, *a4 y *a5 se declaran como apuntadores de + ➥tipo estructura alumno. a6 es una variable de tipo estructura alumno. */ + + a3 = &a0; /* En este caso al apuntador de tipo estructura alumno a3 + ➥se le asigna la dirección de la variable de tipo estructura alumno, a0. */ + + a4 = new (struct alumno); //Revisar operador "new" + /* Nota que al apuntador a4 es necesario asignarle una dirección de memoria. + ➥Para tener acceso a los campos de un apuntador de tipo estructura, utiliza uno + ➥de los dos formatos siguientes: + + apuntador->campo + o bien + (*apuntador).campo + + En la lectura de los campos de la variable a4 se utilizan como ejemplo ambos + ➥formatos. */ + + printf("\nIngrese la matricula del alumno 4: "); + scanf("%d", &(*a4).matricula); + fflush(stdin); + + printf("Ingrese el nombre del alumno 4: "); + gets(a4->nombre); + + printf("Ingrese la carrera del alumno 4: "); + gets((*a4).carrera); + + printf("Ingrese promedio del alumno 4: "); + scanf("%f", &a4->promedio); + fflush(stdin); + + printf("Ingrese la direccion del alumno 4: "); + gets(a4->direccion); + + a5 = new (struct alumno); //Revisar operador "new" + + Lectura(a5); /* En este caso se pasa el apuntador de tipo estructura alumno + a5 a la función Lectura. */ + + Lectura(&a6); /* En este caso se pasa la variable de tipo estructura alumno a6, + ➥a la función Lectura. Observa que en este caso debemos utilizar el operador de + ➥dirección para preceder a la variable. */ + + printf("\nDatos del alumno 3\n"); + /* Observa la forma de escribir los campos de los apuntadores de tipo + ➥estructura. */ + printf("%d\t %s\t %s\t %.2f\t %s", a3->matricula, a3->nombre, a3->carrera, a3->promedio, a3->direccion); + + printf("\nDatos del alumno 4\n"); + printf("%d\t %s\t %s\t %.2f\t %s", a4->matricula, a4->nombre, a4->carrera, a4->promedio, a4->direccion); + + printf("\nDatos del alumno 5\n"); + printf("%d\t %s\t %s\t %f\t %s", a5->matricula, a5->nombre, a5->carrera, a5->promedio, a5->direccion); + + printf("\nDatos del alumno 6\n"); + /* Observa la forma de escribir los campos de la variable tipo estructura. */ + printf("%d\t %s\t %s\t %.2f\t %s", a6.matricula, a6.nombre, a6.carrera, a6.promedio, a6.direccion); +} + +void Lectura(struct alumno* a) +/* Esta función permite leer los campos de un apuntador de tipo estructura +➥alumno. */ +{ + printf("\nIngrese la matricula del alumno: "); + scanf("%d", &(*a).matricula); + fflush(stdin); + + printf("Ingrese el nombre del alumno: "); + gets(a->nombre); + fflush(stdin); + + printf("Ingrese la carrera del alumno: "); + gets((*a).carrera); + + printf("Ingrese el promedio del alumno: "); + scanf("%f", &a->promedio); + fflush(stdin); + + printf("Ingrese la direccion del alumno: "); + gets(a->direccion); +} diff --git a/8. Estructuras y uniones/Programas/Programa 8.3/Programa 8.3.c b/8. Estructuras y uniones/Programas/Programa 8.3/Programa 8.3.c new file mode 100644 index 0000000..dd931ef --- /dev/null +++ b/8. Estructuras y uniones/Programas/Programa 8.3/Programa 8.3.c @@ -0,0 +1,128 @@ +#include +#include + +/* Estructuras-3. +El programa muestra la manera en que se declara una estructura anidada, así +➥como la forma de acceso a los campos de las variables o apuntadores de tipo +➥estructura, tanto para lectura como para escritura. Se utiliza además una +➥función que recibe como parámetro un apuntador de tipo estructura. */ + +typedef struct /* Declaración de la estructura domicilio utilizando un typedef. */ +{ + char calle[20]; + int numero; + int cp; + char localidad[20]; +} domicilio; + +struct empleado /* Declaración de la estructura anidada empleado. */ +{ + char nombre[20]; + char departamento[20]; + float sueldo; + domicilio direccion; /* direccion es un campo de tipo estructura domicilio de la estructura empleado. */ +}; + +void Lectura(struct empleado* a) +/* Función que permite leer los campos de un apuntador de tipo estructura +➥empleado. */ +{ + printf("\nIngrese el nombre del empleado: "); + gets(a->nombre); + fflush(stdin); + + printf("Ingrese el departamento de la empresa: "); + gets(a->departamento); + + printf("Ingrese el sueldo del empleado: "); + scanf("%f", &a->sueldo); + fflush(stdin); + + printf("—-Ingrese la direccion del empleado—-"); + printf("\n\tCalle: "); + gets(a->direccion.calle); + + printf("\tNumero: "); + scanf("%d", &a->direccion.numero); + + printf("\tCodigo Postal: "); + scanf("%d", &a->direccion.cp); + fflush(stdin); + + printf("\tLocalidad: "); + gets(a->direccion.localidad); +} +void main(void) +{ + struct empleado e0 = {"Arturo", "Compras", 15500.75, "San Jeronimo", 120, 3490, "Toluca"}; + struct empleado*e1, *e2, e3, e4; + /* Se declaran diferentes variables y apuntadores de la estructura empleado + ➥para que el lector pueda apreciar también las diferentes formas en que los campos reciben valores. */ + /* En el programa principal se leen los campos de una variable, e3, y un + ➥apuntador de tipo estructura, *e1. */ + + e1 = new (struct empleado); + + printf("\nIngrese el nombre del empleado 1: "); + scanf("%s", &(*e1).nombre); + fflush(stdin); + + printf("Ingrese el departamento de la empresa: "); + gets(e1->departamento); + + printf("Ingrese el sueldo del empleado: "); + scanf("%f", &e1->sueldo); + + printf("—-Ingrese la direccion del empleado—-”"); + printf("\n\tCalle: "); + fflush(stdin); + gets(e1->direccion.calle); + + printf("\tNumero: "); + scanf("%d", &e1->direccion.numero); + + printf("\tCodigo Postal: "); + scanf("%d", &e1->direccion.cp); + + printf("\tLocalidad: "); + fflush(stdin); + gets(e1->direccion.localidad); + + printf("\nIngrese el nombre del empleado 3: "); + scanf("%s", &e3.nombre); + fflush(stdin); + + printf("Ingrese el departamento de la empresa: "); + gets(e3.departamento); + + printf("Ingrese el sueldo del empleado: "); + scanf("%f", &e3.sueldo); + + printf("—-Ingrese la direccion del empleado—-"); + printf("\n\tCalle: "); + fflush(stdin); + gets(e3.direccion.calle); + + printf("\tNumero: "); + scanf("%d", &e3.direccion.numero); + + printf("\tCodigo Postal: "); + scanf("%d", &e3.direccion.cp); + + printf("\tLocalidad: "); + fflush(stdin); + gets(e3.direccion.localidad); + + /* En la función Lectura se leen los campos de una variable, e4, y un apuntador +➥de tipo estructura, *e2. */ + e2 = new (struct empleado); //Revisar operador "new" + Lectura(e2); + Lectura(&e4); + + printf("\nDatos del empleado 1:\n"); + printf("%s\t %s\t %.2f\t %s\t %d\t %d\t %s", e1->nombre, e1->departamento, e1->sueldo, e1->direccion.calle, e1->direccion.numero, e1->direccion.cp, e1->direccion.localidad); + + printf("\nDatos del empleado 4:\n"); + printf("%s\t %s\t %.2f\t %s\t %d\t %d\t %s", e4.nombre, e4.departamento, e4.sueldo, e4.direccion.calle, e4.direccion.numero, e4.direccion.cp, e4.direccion.localidad); +} + diff --git a/8. Estructuras y uniones/Programas/Programa 8.4/Programa 8.4.c b/8. Estructuras y uniones/Programas/Programa 8.4/Programa 8.4.c new file mode 100644 index 0000000..b571628 --- /dev/null +++ b/8. Estructuras y uniones/Programas/Programa 8.4/Programa 8.4.c @@ -0,0 +1,108 @@ +#include +#include + +/* Escuela. +El programa genera información estadística de los alumnos de una escuela. */ + +typedef struct /* Declaración de la estructura alumno utilizando un +➥typedef. */ +{ + int matricula; + char nombre[30]; + float cal[5]; + /* Observa que el campo de la estructura alumno es un arreglo + ➥unidimensional. */ +} alumno; + +void Lectura(alumno, int T); +void F1(alumno*, int TAM); /* Prototipos de funciones. */ +void F2(alumno*, int TAM); +void F3(alumno*, int TAM); + + +void main(void) +{ + alumno ARRE[50]; /* Se declara un arreglo unidimensional de tipo alumno. */ + int TAM; + do + { + printf("Ingrese el tamaño del arreglo: "); + scanf("%d", &TAM); + } while (TAM > 50 || TAM < 1); /* Se verifica que el tamaño del arreglo sea + ➥correcto. */ + + Lectura(ARRE, TAM); + F1(ARRE, TAM); + F2(ARRE, TAM); + F3(ARRE, TAM); +} + +void Lectura(alumno A[], int T) +/* La función Lectura se utiliza para leer un arreglo unidimensional de tipo +➥estructura alumno de T elementos. */ +{ + int I, J; + for (I = 0; I < T; I++) + { + printf("\nIngrese los datos del alumno %d", I + 1); + printf("\nIngrese la matricula del alumno: "); + scanf("%d", &A[I].matricula); + fflush(stdin); + + printf("Ingrese el nombre del alumno: "); + gets(A[I].nombre); + + for (J = 0; J < 5; J++) + { + printf("\tIngrese la calificacion %d del alumno %d: ", J + 1, I + 1); + scanf("%f", &A[I].cal[J]); + } + } +} + +void F1(alumno A[], int T) +/* La función F1 obtiene la matrícula y el promedio de cada alumno. */ +{ + int I, J; + float SUM, PRO; + for (I = 0; I < T; I++) + { + printf("\nMatricula del alumno: %d", A[I].matricula); + + SUM = 0.0; + + for (J = 0; J < 5; J++) + SUM = SUM + A[I].cal[J]; + + PRO = SUM / 5; + + printf("\t\tPromedio: % .2f", PRO); + } +} + +void F2(alumno A[], int T) +/* La función F2 obtiene las matrículas de los alumnos cuya calificación en la +➥tercera materia es mayor a 9. */ +{ + int I; + + printf("\nAlumnos con calificacion en la tercera materia > 9"); + + for (I = 0; I < T; I++) + if (A[I].cal[2] > 9) + printf("\nMatricula del alumno: %d", A[I].matricula); +} + +void F3(alumno A[], int T) +/* Esta función obtiene el promedio general del grupo de la materia 4. */ +{ + int I; + float PRO, SUM = 0.0; + + for (I = 0; I < T; I++) + SUM = SUM + A[I].cal[3]; + + PRO = SUM / T; + + printf("\n\nPromedio de la materia 4: %.2f", PRO); +} diff --git a/8. Estructuras y uniones/Programas/Programa 8.5/Programa 8.5.c b/8. Estructuras y uniones/Programas/Programa 8.5/Programa 8.5.c new file mode 100644 index 0000000..6b113e0 --- /dev/null +++ b/8. Estructuras y uniones/Programas/Programa 8.5/Programa 8.5.c @@ -0,0 +1,135 @@ +#include +#include + +/* Uniones. +El programa muestra la manera como se declara una unión, así como la forma de +➥acceso a los campos de las variables de tipo unión tanto para asignación +➥de valores como para lectura y escritura. */ + +union datos /* Declaración de una unión. */ +{ + char celular[15]; + char correo[20]; +}; + +typedef struct /* Declaración de una estructura utilizando typedef. */ +{ + int matricula; + char nombre[20]; + char carrera[20]; + float promedio; + union datos personales; + /* Observa que uno de los campos de la estructura alumno es una unión. */ +} alumno; + +void Lectura(alumno a); /* Prototipo de función. */ + +void main(void) +{ + alumno a1 = { 120, "Maria", "Contabilidad", 8.9, "5-158-40-50"}, a2, a3; + /* Observa que sólo el primer componente de una unión puede recibir valores por + ➥medio de este tipo de asignaciones. */ + /* Para que puedas observar las diferentes formas en que los campos de las + ➥variables de tipo estructura alumno reciben valores, ingresamos los valores + ➥de los campos de tres formas diferentes. Los campos de a1 reciben valores + ➥directamente, los campos de a2 se leen en el programa principal, y los campos + ➥de a3 reciben valores a través de una función. */ + + printf("Alumno 2\n"); + + printf("Ingrese la matricula: "); + scanf("%d", &a2.matricula); + fflush(stdin); + + printf("Ingrese el nombr : "); + gets(a2.nombre); + fflush(stdin); + + printf("Ingrese la carrera: "); + gets(a2.carrera); + + printf("Ingrese el promedio: "); + scanf("%f", &a2.promedio); + fflush(stdin); + + printf("Ingrese el correo electronico: "); + gets(a2.personales.correo); + /* Observa que en la variable a2 de tipo estructura alumno el segundo campo de la + ➥unión recibe un valor. */ + + printf("Alumno 3\n"); + Lectura(&a3); /* Se llama a una función para leer los campos de la variable a3. */ + /* Impresión de resultados. */ + + printf("\nDatos del alumno 1\n"); + printf("%d\n", a1.matricula); + + puts(a1.nombre); + puts(a1.carrera); + + printf("%.2f\n", a1.promedio); + puts(a1.personales.celular); + /* Observa que escribe el valor del teléfono celular asignado. */ + + puts(a1.personales.correo); + /* Observa que si tratamos de imprimir el campo correo, escribe basura. */ + + strcpy(a0.personales.correo, "hgimenez@hotmail.com"); + /* Se ingresa ahora un valor al segundo campo de la unión de la variable a0. */ + + puts(a0.personales.celular); + /* Ahora escribe basura en el campo del teléfono celular. */ + + puts(a0.personales.correo); + /* Escribe el contenido del campo (hgimenez@hotmail.com). */ + + printf("\nDatos del alumno 2\n"); + printf("%d\n", a2.matricula); + puts(a2.nombre); + puts(a2.carrera); + + printf("%.2f\n", a2.promedio); + puts(a2.personales.celular); /* Escribe basura. */ + puts(a2.personales.correo); /* Escribe el contenido del segundo campo. */ + + printf("Ingrese el telefono celular del alumno 2: "); + fflush(stdin); + + gets(a2.personales.celular); + puts(a2.personales.celular); /* Escribe el teléfono celular ingresado. */ + puts(a2.personales.correo); /* Ahora escribe basura. */ + + printf("\nDatos del alumno 3\n"); + printf("%d\n", a3.matricula); + puts(a3.nombre); + puts(a3.carrera); + + printf("%.2f\n", a3.promedio); + puts(a3.personales.celular); + puts(a3.personales.correo); /* Escribe basura. */ +} + + +void Lectura(alumno* a) +/* La función Lectura se utiliza para leer los campos de una variable de tipo +➥estructura alumno. */ +{ + printf("\nIngrese la matricula: "); + scanf("%d", &(*a).matricula); + fflush(stdin); + + printf("Ingrese el nombre: "); + gets(a->nombre); + fflush(stdin); + + printf("Ingrese la carrera: "); + gets((*a).carrera); + + printf("Ingrese el promedio: "); + scanf("%f", &a->promedio); + + printf("Ingrese el telefono celular: "); + fflush(stdin); + gets(a->personales.celular); +} + diff --git a/8. Estructuras y uniones/Programas/Programa 8.6/Programa 8.6.c b/8. Estructuras y uniones/Programas/Programa 8.6/Programa 8.6.c new file mode 100644 index 0000000..6f539fe --- /dev/null +++ b/8. Estructuras y uniones/Programas/Programa 8.6/Programa 8.6.c @@ -0,0 +1,244 @@ +#include +#include + +/* Comercializadora farmacéutica. +El programa maneja información sobre ventas, inventario, reabastecimiento y +➥nuevos productos de una comercializadora farmacéutica. */ + +typedef struct /* Declaración de la estructura producto. */ +{ + int clave; + char nombre[15]; + float precio; + int existencia; +} producto; + +void Lectura(producto*, int); /* Prototipos de funciones. */ +void Ventas(producto*, int); +void Reabastecimiento(producto*, int); +void Nuevos_Productos(producto*, int*); +void Inventario(producto*, int); + +void main(void) +{ + producto INV[100]; + /* Se declara un arreglo unidimensional de tipo estructura producto. */ + int TAM, OPE; + + do + { + printf("Ingrese el numero de productos: "); + scanf("%d", &TAM); + } while (TAM > 100 || TAM < 1); + /* Se verifica que el número de productos ingresados sea correcto. */ + + Lectura(INV, TAM); + + printf("\nIngrese operacion a realizar. \n\t\t1 – Ventas \n\t\t 2 – Reabastecimiento \n\t\t3 - Nuevos Productos \n\t\t 4 – Inventario \n\t\t 0 - Salir: "); + scanf("%d", &OPE); + while (OPE) + { + switch (OPE) + { + case 1: Ventas(INV, TAM); + break; + + case 2: Reabastecimiento(INV, TAM); + break; + + case 3: Nuevos_Productos(INV, &TAM); + /* Se pasa el parámetro por referencia, porque se puede modificar el + ➥número de elementos del arreglo en la función. */ + break; + + case 4: Inventario(INV, TAM); + break; + }; + + printf("\nIngrese operacion a realizar. \n\t\t 1 – Ventas \n\t\t 2 – Reabastecimiento \n\t\t 3 - Nuevos Productos \n\t\t 4 – Inventario \n\t\t 0 - Salir: "); + scanf("%d", &OPE); + } +} +void Lectura(producto A[], int T) +/* Esta función se utiliza para leer un arreglo unidimensional de tipo +➥estructura producto de T elementos. */ +{ + int I; + for (I = 0; I < T; I++) + { + printf("\nIngrese informacion del producto %d", I + 1); + printf("\n\tClave: "); + scanf("%d", &A[I].clave); + fflush(stdin); + + printf("\tNombre: "); + gets(A[I].nombre); + + printf("\tPrecio: "); + scanf("%f", &A[I].precio); + + printf("\tExistencia: "); + scanf("%d", &A[I].existencia); + } +} +void Ventas(producto A[], int T) +/* Esta función se utiliza para manejar las venta a un cliente. Se ingresan +➥productos y cantidades, el fin de datos está dado por el cero. Además de +➥obtener el total de las ventas, se actualiza el inventario. */ +{ + int CLA, CAN, I, RES; + float TOT, PAR; + + printf("\nIngrese clave del producto - 0 para salir -: "); + scanf("%d", &CLA); + + TOT = 0.0; + + while (CLA) + { + printf("\tCantidad: "); + scanf("%d", &CAN); + + I = 0; + + while ((I < T) && (A[I].clave < CLA)) + /* Se realiza una búsqueda para localizar la clave del producto. */ + I++; + + if ((I == T) || (A[I].clave > CLA)) + printf("\nLa clave del producto es incorrecta"); + + else + if (A[I].existencia >= CAN) + /* Se analiza si el stock es suficiente para satisfacer el pedido. */ + { + A[I].existencia -= CAN; /* Se actualiza el stock del producto. */ + PAR = A[I].precio * CAN; + TOT += PAR; + } + else + { + printf("\nNo existe en inventario la cantidad solicitada. Solo hay %d", A[I].existencia); + printf("\nLos lleva 1-Si 0–No?: "); + scanf("%d", &RES); + if (RES) + { + PAR = A[I].precio * A[I].existencia; + A[I].existencia = 0; /* El stock queda en cero. */ + TOT += PAR; + } + } + printf("\nIngrese la siguiente clave del producto - 0 para salir-: "); + scanf("%d", &CLA); + } + printf("\nTotal de la venta: %f", TOT); +} + +void Reabastecimiento(producto A[], int T) +/* Esta función se utiliza para reabastecer al inventario. */ +{ + int CLA, CAN, I; + printf("\nIngrese clave del producto - 0 para salir -: "); + scanf("%d", &CLA); + + while (CLA) + { + I = 0; + while ((I < T) && (A[I].clave < CLA)) + I++; + if ((I == T) || (A[I].clave > CLA)) + printf("\nLa clave del producto ingresada es incorrecta"); + + else + { + printf("\tCantidad: "); + scanf("%d", &CAN); + A[I].existencia += CAN; + } + printf("\nIngrese otra clave del producto - 0 para salir -: "); + scanf("%d", &CLA); + } +} + +void Nuevos_Productos(producto A[], int* T) +/* Esta función se utiliza para incorporar nuevos productos al inventario. +➥Dado que los productos se encuentran ordenados por clave, puede suceder que +➥al insertar un nuevo producto haya que mover los elementos del arreglo para +➥que continúen ordenados. */ +{ + int CLA, I, J; + printf("\nIngrese clave del producto - 0 para salir -: "); + scanf("%d", &CLA); + + while ((*T < 30) && (CLA)) + { + I = 0; + while ((I < *T) && (A[I].clave < CLA)) + /* Búsqueda de la posición que le corresponde a CLA en el arreglo. */ + I++; + + if (I == *T) /* Se inserta el elemento en la última posición. */ + { + A[I].clave = CLA; + printf("\tNombre: "); + fflush(stdin); + gets(A[I].nombre); + + printf("\tPrecio: "); + scanf("%f", &A[I].precio); + + printf("\tCantidad: "); + scanf("%d", &A[I].existencia); + *T = *T + 1; + } + + else + if (A[I].clave == CLA) + printf("\nEl producto ya se encuentra en el inventario."); + + else + { + for (J = *T; J > I; J--) + /* Se inserta el nuevo producto en el arreglo. Se mueven una posición + ➥a la derecha los elementos + del arreglo que tengan una clave de producto mayor a la ingresada. */ + + A[J] = A[J - 1]; + + A[I].clave = CLA; + + printf("\tNombre: "); + fflush(stdin); + gets(A[I].nombre); + + printf("\tPrecio: "); + scanf("%f", &A[I].precio); + + printf("\tCantidad: "); + scanf("%d", &A[I].existencia); + *T = *T + 1; + } + printf("\nIngrese otra clave de producto - 0 para salir -: "); + scanf("%d", &CLA); + } + if (*T == 30) + printf("\nYa no hay espacio para incorporar nuevos productos."); +} + +void Inventario(producto A[], int T) +/* Esta función se utiliza para escribir la información almacenada en —el +➥inventario— un arreglo unidimensional de tipo estructura producto de T +➥elementos. */ +{ + int I; + for (I = 0; I < T; I++) + { + printf("\nClave: %d", A[I].clave); + + printf("\tNombre: %s", A[I].nombre); + + printf("\tPrecio: %d", A[I].precio); + + printf("\tExistencia: %d \n", A[I].existencia); + } +} diff --git a/8. Estructuras y uniones/Programas/Programa 8.7/Programa 8.7.c b/8. Estructuras y uniones/Programas/Programa 8.7/Programa 8.7.c new file mode 100644 index 0000000..2fc7960 --- /dev/null +++ b/8. Estructuras y uniones/Programas/Programa 8.7/Programa 8.7.c @@ -0,0 +1,114 @@ +#include +#include + +/* Escuela. +El programa genera información importante de los alumnos de una escuela. */ + +typedef struct /* Declaración de la estructura matpro. */ +{ + char mat[20]; /* Materia. */ + int pro; /* Promedio. */ +} matpro; + +typedef struct /* Declaración de la estructura alumno. */ +{ + int matri; /* Matrícula. */ + char nom[20]; /* Nombre del alumno. */ + matpro cal[5]; /* Observa que cal es un arreglo unidimensional de tipo + ➥estructura + matpro —la estructura definida en primer término. */ +} alumno; + +void Lectura(alumno*, int); +void F1(alumno*, int); +void F2(alumno*, int); /* Prototipos de funciones. */ +void F3(alumno*, int); + +void main(void) +{ + alumno ALU[50]; /* ALU es un arreglo unidimensional de tipo alumno. */ + int TAM; + do + { + printf("Ingrese el tamaño del arreglo: "); + scanf("%d", &TAM); + } while (TAM > 50 || TAM < 1); /* Se verifica que el tamaño del arreglo sea correcto. */ + + Lectura(ALU, TAM); + F1(ALU, TAM); + F2(ALU, TAM); + F3(ALU, TAM); +} + +void Lectura(alumno A[], int T) +/* Esta función se utiliza para leer la información de un arreglo unidimensional +➥de tipo estructura alumno de T elementos. */ +{ + int I, J; + for (I = 0; I < T; I++) + { + printf("\nIngrese los datos del alumno %d", I + 1); + printf("\nIngrese la matricula del alumno: "); + scanf("%d", &A[I].matri); + fflush(stdin); + + printf("Ingrese el nombre del alumno: "); + gets(A[I].nom); + + for (J = 0; J < 5; J++) + { + printf("\tMateria %d: ", J + 1); + fflush(stdin); + gets(A[I].cal[J].mat); + + printf("\tPromedio %d: ", J + 1); + scanf("%d", &A[I].cal[J].pro); + } + } +} + +void F1(alumno A[], int T) +/* Esta función se utiliza para obtener la matrícula y el promedio general de +➥cada alumno. */ +{ + int I, J; + float SUM; + for (I = 0; I < T; I++) + { + printf("\nMatricula del alumno: %d", A[I].matri); + SUM = 0.0; + + for (J = 0; J < 5; J++) + SUM = SUM + A[I].cal[J].pro; + + SUM = SUM / 5; + + printf("\tPromedio: %.2f", SUM); + } +} + +void F2(alumno A[], int T) +/* Esta función se utiliza para obtener las matrículas de los alumnos cuya +➥calificación en la tercera materia es mayor a 9. */ +{ + int I; + printf("\nAlumnos con calificacion mayor a 9 en la tercera materia"); + + for (I = 0; I < T; I++) + if (A[I].cal[2].pro > 9) + printf("\nMatricula del alumno: %d", A[I].matri); +} + +void F3(alumno A[], int T) +/* Esta función se utiliza para obtener el promedio general de la cuarta materia. */ +{ + int I; + float SUM = 0.0; + + for (I = 0; I < T; I++) + SUM = SUM + A[I].cal[3].pro; + + SUM = SUM / T; + + printf("\n\nPromedio de la cuarta materia: %.2f", SUM); +} diff --git a/8. Estructuras y uniones/Programas/Programa 8.8/Programa 8.8.c b/8. Estructuras y uniones/Programas/Programa 8.8/Programa 8.8.c new file mode 100644 index 0000000..0b4da28 --- /dev/null +++ b/8. Estructuras y uniones/Programas/Programa 8.8/Programa 8.8.c @@ -0,0 +1,150 @@ +#include +#include + +/* Hospital. +El programa genera información acerca de los pacientes de un hospital. */ + +typedef struct /* Declaración de la estructura domicilio. */ +{ + char cal[20]; /* Calle. */ + int num; /* Número. */ + char col[20]; /* Colonia. */ + char cp[5]; /* Código Postal. */ + char ciu[20]; /* Ciudad. */ +} domicilio; + +typedef struct /* Declaración de la estructura paciente. */ +{ + char nom[20]; /* Nombre y apellido. */ + int edad; + char sexo; + int con; /* Condición. */ + domicilio dom; /* Observa que el campo dom es de tipo estructura domicilio. */ + char tel[10]; /* Teléfono. */ +} paciente; + +void Lectura(paciente*, int); +void F1(paciente*, int); +void F2(paciente*, int); /* Prototipos de funciones. */ +void F3(paciente*, int); + +void main(void) +{ + paciente HOSPITAL[100]; /* Arreglo unidimensional de tipo estructura paciente. */ + int TAM = 0; + do + { + printf("Ingrese el numero de pacientes: "); + scanf("%d", &TAM); + + } while (TAM > 50 || TAM < 1); /* Se verifica que el tamaño del arreglo sea correcto. */ + + Lectura(HOSPITAL, TAM); + F1(HOSPITAL, TAM); + F2(HOSPITAL, TAM); + F3(HOSPITAL, TAM); +} +void Lectura(paciente A[], int T) +/* Esta función se utiliza para leer un arreglo unidimensional de tipo +➥estructura paciente de T elementos. */ +{ + int I; + for (I = 0; I < T; I++) + { + printf("\n\t\tPaciente % d", I + 1); + fflush(stdin); + printf("\nNombre: "); + gets(A[I].nom); + + printf("Edad: "); + scanf("%d", &A[I].edad); + + printf("Sexo (F - M): "); + scanf("%c", &A[I].sexo); + + printf("Condicion (1..5): "); + scanf("%d", &A[I].con); + fflush(stdin); + + printf("\tCalle: "); + gets(A[I].dom.cal); + + printf("\tNumero: "); + scanf("%d", &A[I].dom.num); + fflush(stdin); + + printf("\tColonia: "); + gets(A[I].dom.col); + fflush(stdin); + + printf("\tCodigo Postal : "); + gets(A[I].dom.cp); + fflush(stdin); + + printf("\tCiudad: "); + gets(A[I].dom.ciu); + fflush(stdin); + + printf("Telefono: "); + gets(A[I].tel); + } +} +void F1(paciente A[], int T) +/* Esta función se utiliza para obtener el porcentaje tanto de hombres como de +➥mujeres registrados en el hospital. */ +{ + int I, FEM = 0, MAS = 0, TOT; + + for (I = 0; I < T; I++) + switch (A[I].sexo) + { + case 'F': FEM++; + break; + case 'M': MAS++; + break; + } + + TOT = FEM + MAS; + printf("\nPorcentaje de Hombres: %.2f %", (float)MAS / TOT * 100); + printf("\nPorcentaje de Mujeres: %.2f %", (float)FEM / TOT * 100); +} + +void F2(paciente A[], int T) +/* Esta función se utiliza para obtener el número de pacientes que ingresaron al +➥hospital en cada una de las categorías de condición. */ +{ + int I, C1 = 0, C2 = 0, C3 = 0, C4 = 0, C5 = 0; + for (I = 0; I < T; I++) + switch (A[I].con) + { + case 1: C1++; + break; + case 2: C2++; + break; + case 3: C3++; + break; + case 4: C4++; + break; + case 5: C5++; + break; + } + + printf("\nNumero pacientes en condición 1: %d", C1); + printf("\nNumero pacientes en condición 2: %d", C2); + printf("\nNumero pacientes en condición 3: %d", C3); + printf("\nNumero pacientes en condición 4: %d", C4); + printf("\nNumero pacientes en condición 5: %d", C5); +} + +void F3(paciente A[], int T) +/* La función F3 se utiliza para generar el nombre y teléfono de todos los +➥pacientes que tuvieron una condición de ingreso de máxima gravedad (5). */ +{ + int I; + + printf("\nPacientes ingresados en estado de gravedad"); + + for (I = 0; I < T; I++) + if (A[I].con == 5) + printf("\nNombre: %s\tTelefono: %s", A[I].nom, A[I].tel); +} diff --git a/8. Estructuras y uniones/Programas/Programa 8.9/Programa 8.9.c b/8. Estructuras y uniones/Programas/Programa 8.9/Programa 8.9.c new file mode 100644 index 0000000..061c8f4 --- /dev/null +++ b/8. Estructuras y uniones/Programas/Programa 8.9/Programa 8.9.c @@ -0,0 +1,162 @@ +#include +#include + +/* Bienes raíces. +El programa maneja información sobre las propiedades que tiene una empresa +➥de bienes raíces de la ciudad de Lima, Perú, tanto para venta como para +➥renta. */ + +typedef struct /* Declaración de la estructura ubicación.*/ +{ + char zona[20]; + char calle[20]; + char colo[20]; /* Colonia. */ +} ubicacion; + +typedef struct /* Declaración de la estructura propiedades.*/ +{ + char clave[5]; + float scu; /* Superficie cubierta. */ + float ste; /* Superficie terreno. */ + char car[50]; /* Características. */ + ubicacion ubi; /* Observa que este campo es de tipo estructura + ubicación. */ + float precio; + char dispo; /* Disponibilidad. */ +} propiedades; + +void Lectura(propiedades, int); +void F1(propiedades*, int); /* Prototipos de funciones. */ +void F2(propiedades*, int); + +void main(void) +{ + propiedades PROPIE[100]; + /* Se declara un arreglo unidimensional de tipo estructura propiedades. */ + int TAM; + + do + { + printf("Ingrese el numero de propiedades: "); + scanf("%d", &TAM); + } while (TAM > 100 || TAM < 1); + /* Se verifica que el tamaño del arreglo sea correcto. */ + + Lectura(PROPIE, TAM); + F1(PROPIE, TAM); + F2(PROPIE, TAM); +} + +void Lectura(propiedades A[], int T) +/* Esta función se utiliza para leer un arreglo unidimensional de tipo estructura +➥propiedades de T elementos. */ +{ + int I; + + for (I = 0; I < T; I++) + { + printf("\n\tIngrese datos de la propiedad %d", I + 1); + printf("\nClave: "); + fflush(stdin); + gets(A[I].clave); + + printf("Superficie cubierta: "); + scanf("%f", &A[I].scu); + + printf("Superficie terreno: "); + scanf("%f", &A[I].ste); + + printf("Caracteristicas: "); + fflush(stdin); + gets(A[I].car); + + printf("\tZona: "); + fflush(stdin); + gets(A[I].ubi.zona); + + printf("\tCalle: "); + fflush(stdin); + gets(A[I].ubi.calle); + + printf("\tColonia: "); + fflush(stdin); + gets(A[I].ubi.colo); + + printf("Precio: "); + scanf("%f", &A[I].precio); + + printf("Disponibilidad (Venta - V Renta - R): "); + scanf("%c", &A[I].dispo); + } +} + +void F1(propiedades A[], int T) +/* Esta función se utiliza para generar un listado de las propiedades +➥disponibles para venta en la zona de Miraflores, cuyo valor oscila entre +➥450,000 y 650,000 nuevos soles. */ +{ + int I; + printf("\n\t\tListado de Propiedades para Venta en Miraflores"); + for (I = 0; I < T; I++) + if ((A[I].dispo == 'V') && (strcmp(A[I].ubi.zona, "Miraflores") == 0)) + if ((A[I].precio >= 450000) && (A[I].precio <= 650000)) + { + printf("\nClave de la propiedad: "); + puts(A[I].clave); + + printf("\nSuperficie cubierta: %f", A[I].scu); + printf("\nSuperficie terreno: %f", A[I].ste); + printf("\nCaracteristicas: "); + puts(A[I].car); + + printf("Calle: "); + puts(A[I].ubi.calle); + + printf("Colonia: "); + puts(A[I].ubi.colo); + + printf("Precio: %.2f\n", A[I].precio); + } +} + +void F2(propiedades A[], int T) +/* Al recibir como datos una zona geográfica de Lima, Perú, y un cierto rango +➥respecto al monto, esta función genera un listado de todas las propiedades +➥disponibles para renta. */ +{ + int I; + float li, ls; + char zon[20]; + + printf("\n\t\tListado de Propiedades para Renta"); + printf("\nIngrese zona geografica: "); + fflush(stdin); + gets(zon); + + printf("Ingrese el limite inferior del precio: "); + scanf("%f", &li); + + printf("Ingrese el limite superior del precio: "); + scanf("%f", &ls); + + for (I = 0; I < T; I++) + if ((A[I].dispo == 'R') && (strcmp(A[I].ubi.zona, zon) == 0)) + if ((A[I].precio >= li) && (A[I].precio <= ls)) + { + printf("\nClave de la propiedad: "); + puts(A[I].clave); + + printf("\nSuperficie cubierta: %d", A[I].scu); + printf("\nSuperficie terreno: %d", A[I].ste); + printf("\nCaracteristicas: "); + puts(A[I].car); + + printf("Calle: "); + puts(A[I].ubi.calle); + + printf("Colonia: "); + puts(A[I].ubi.colo); + + printf("Precio: %.2f", A[I].precio); + } +}