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

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);
}
}