jorgenicolas/Curso_de_Programacion_C
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

16/11/2022 ; 6:15 PM

Browse Source
This commit is contained in:
JNmeca
2022-11-16 18:17:05 -04:00
parent b51d1043c8
commit c0fecc3536
10 changed files with 1473 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
8. Estructuras y uniones/Programas/Programa 8.1/Programa 8.1.c Normal file
View File

@@ -0,0 +1,97 @@
#include <stdio.h>
#include <string.h>
/* 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);
}

228
8. Estructuras y uniones/Programas/Programa 8.10/Programa 8.10.c Normal file
View File

@@ -0,0 +1,228 @@
#include <stdio.h>
#include <string.h>
/* 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);
}

107
8. Estructuras y uniones/Programas/Programa 8.2/Programa 8.2.c Normal file
View File

@@ -0,0 +1,107 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* 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);
}

128
8. Estructuras y uniones/Programas/Programa 8.3/Programa 8.3.c Normal file
View File

@@ -0,0 +1,128 @@
#include <stdio.h>
#include <string.h>
/* 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);
}

108
8. Estructuras y uniones/Programas/Programa 8.4/Programa 8.4.c Normal file
View File

@@ -0,0 +1,108 @@
#include <stdio.h>
#include <string.h>
/* 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);
}

135
8. Estructuras y uniones/Programas/Programa 8.5/Programa 8.5.c Normal file
View File

@@ -0,0 +1,135 @@
#include <stdio.h>
#include <string.h>
/* 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);
}

244
8. Estructuras y uniones/Programas/Programa 8.6/Programa 8.6.c Normal file
View File

@@ -0,0 +1,244 @@
#include <stdio.h>
#include <string.h>
/* 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);
}
}

114
8. Estructuras y uniones/Programas/Programa 8.7/Programa 8.7.c Normal file
View File

@@ -0,0 +1,114 @@
#include <stdio.h>
#include <string.h>
/* 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);
}

150
8. Estructuras y uniones/Programas/Programa 8.8/Programa 8.8.c Normal file
View File

@@ -0,0 +1,150 @@
#include <stdio.h>
#include <string.h>
/* 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);
}

162
8. Estructuras y uniones/Programas/Programa 8.9/Programa 8.9.c Normal file
View File

@@ -0,0 +1,162 @@
#include <stdio.h>
#include <string.h>
/* 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);
}
}