PROGRAMACIÓN VISUAL

REPORTE DE PRÁCTICA #2

Alumno: Marcus André Menegatti da Costa

Número de Control: 21130040
Carrera: Ing. Electrónica
Profesor: Alejandro Enrique Dzul Lopez

Torreón, Coahuila, 23/09/2022

Semestre: 04.2022
Índice
1. INTRODUCCIÓN ..................................................................................................................... 2
2. ANÁLISIS ................................................................................................................................ 2
 Función main(): ................................................................................................................. 3
 Función menu(): ................................................................................................................ 4
 Función llenar_inv():.......................................................................................................... 4
 Función ord_np(): .............................................................................................................. 5
 Función ord_p(): ................................................................................................................ 6
 Función ord_ctd(): ............................................................................................................. 6
 Función buscar(): ............................................................................................................... 7
 Función mostrar_prod(): ................................................................................................... 8
 Función mostrar_todo(): ................................................................................................... 8
3. CÓDIGO EM C++ .................................................................................................................... 8
4. CONCLUSIÓN ....................................................................................................................... 15

Tabla de Ilustraciones
Ilustración 1. Menu ....................................................................................................................... 3
Ilustración 2. Opción Inválida ........................................................................................................ 3
Ilustración 3. Llenar el inventario .................................................................................................. 4
Ilustración 4. Transformación a mayúsculas ................................................................................. 5
Ilustración 5. Llenar inventario ..................................................................................................... 5
Ilustración 6. Orden alfabético ...................................................................................................... 6
Ilustración 7. Orden de precio de mayor a menor ........................................................................ 6
Ilustración 8.Orden por cantidades de menor a mayor ................................................................ 7
Ilustración 9. Producto no encontrado! ........................................................................................ 7
Ilustración 10. Funcion buscar() .................................................................................................... 8
 1. INTRODUCCIÓN

El objetivo de la actual práctica es desarrollar un programa en lenguaje C/C++,

en modo consola, con un menú repetitivo y que sea capaz de utilizar una
estructura de datos para registrar un inventario, con nombre de cinco productos,
su precio y cantidad.

Para la estructura de datos se requerirá usar como variables internas una cadena
de caracteres (con 30 caracteres, máximo), un valor real y positivo para el precio
y un valor entero y positivo para la cantidad de producto.

Para la resolución de este problema, fue utilizado el lenguaje C++, en el

programa Borland C++ Builder 6.

El programador podrá, a través de las definiciones del programa, cambiar la

cantidad de productos a ser registrada y la cantidad de caracteres del nombre
de los productos.

La metodología empleada para la resolución del programa fue el uso de

estructura de datos, funciones, ciclos y estructuras selectivas.

2. ANÁLISIS

Para el análisis del código, se tomará función por función para una mejor
organización y comprensión.

Antes de analizar las funciones, es importante mencionar la definición de

estructura de datos “Producto”, que trabajará con tres tipos de datos: una
cadena, para el nombre de los productos, un tipo flotante, para el precio, y un
tipo entero, para la cantidad de productos.

Las funciones utilizadas en el programa son: menu(), llenar_inv(), ord_np(),

ord_p(), ord_ctd(), buscar(), mostrar_prod() y mostrar_todo(). Ademas, fue usada
la función principal: main().

2
 Función main():

La función principal main() es donde corre el programa.

Antes de trabajar con las funciones, es definido un arreglo del tipo Producto
y que tiene tamaño igual a 5. Este arreglo contendrá las tres variables
definidas en Producto.

La función principal está formada por todas las funciones anteriormente

mencionadas. Para su funcionamiento, se utiliza el ciclo do…while para
correr, al menos una vez, la función menú(). Al recibir el valor de la opción
del menú, se utilizó la estructura selectiva switch para evaluar cada opción
del número uno al seis. Caso el número digitado esté fuera de este rango, el
mensaje “Opción inválida!” aparece en pantalla.

Ilustración 1. Menu

Ilustración 2. Opción Inválida

Para control del menú se utilizó una variable de control, b1. Esta variable es
bandera que permite que el programa siga funcionando correctamente. Por
ejemplo, si el inventario no es llenado, no se puede ordenar, ni por nombre
de producto, ni por precio, ni por cantidad. De igual manera, no se puede
buscar el producto. Por esto, la variable b1 recibió un valor falso (el cero).
Caso el inventario no sea llenado, esas funciones (de ordenamiento y busca)

3
permanecerán con el valor b1 falso y regresarán el mensaje: “Llenar el
inventario!”.

Ilustración 3. Llenar el inventario

Al llenar el inventario, el valor de b1 cambia a verdadero (1) y permite generar

todas las demás opciones.

Al final del código de la función principal, se utiliza la función getch(), para

esperar a que el usuario teclee algún carácter, y la función clrscr(), para
limpiar la pantalla, por cuestiones de limpieza y estética.

 Función menu():

La función menú() es del tipo entera (int) y regresa el valor de la opción

seleccionada. Está conformada del texto que el usuario lee en pantalla.

 Función llenar_inv():

La función llenar_inv() tiene como objetivo justamente llenar el inventario. Es

formada por un ciclo for. El argumento de la función es la variable l del tipo
Producto.

Es una función vacía (void) y que genera un arreglo de una dimensión que
contiene cinco “renglones”. Cada “renglón” está formado por un paquete de
datos: nombre del producto, su valor y cantidad.

Antes de ingresar el nombre, es importante usar la función fflush(stdin) para

que el usuario pueda llenar correctamente los datos que se piden. Al ingresar
el nombre del producto, la función transforma los caracteres, cualesquiera
4
que sean, en mayúsculas. La transformación es conveniente para que se
tenga un mejor control sobre este dato.

Enseguida, la función usa dos ciclos do…while: una para los precios y otra
para las cantidades. Ambos ciclos tienen la misma función: la de permitir
ingresar datos mayores o iguales a cero. Caso el número ingresado sea
menor que cero, el programa vuelve a pedir el precio o la cantidad, según sea
el caso.

Ilustración 4. Transformación a mayúsculas

Ilustración 5. Llenar inventario

 Función ord_np():

Para la función ord_n() se utilizó el tipo void que recibe un arreglo y genera
otro arreglo, ambos tipo Programa. Lo que hace la función es ordenar por
orden alfabético, de la A hasta la Z, analizando caracter por caracter. La
función es compuesta por dos ciclos for y un if que funcionan como un efecto
burbuja, donde el elemento más “liviano” sube a la primera posición de la
lista. Como es un ordenamiento por nombre, se consideran los caracteres.
Para esto se usa la función strcmp(a,b), que compara una cadena de la lista
con la siguiente. Si la cadena a tiene un valor mayor que b, estas cambian de
posición entre sí. El valor de comparación regresa un número entero. Si

5
strcmp(a,b)>0, quiere decir que la cadena a es mayor alfabéticamente que b.
Si strcmp(a,b)<0, quiere decir que la cadena b es mayor alfabéticamente que
a. Si strcmp(a,b)=0, quiere decir que ambas tiene el mismo valor alfabético.

Ilustración 6. Orden alfabético

Como apreciado en las imágenes, hubo un ordenamiento alfabético.

 Función ord_p():

La función ord_p() hace exactamente lo mismo que la función ord_np(), con

la diferencia que la primera ordena los precios de mayor a menor. La
estructura lógica es casi la misma. Aquí no se trabaja con la función strcmp(),
puesto que los precios son números reales.

Ilustración 7. Orden de precio de mayor a menor

 Función ord_ctd():

La función ord_ctd() funciona de la misma manera que la función anterior. La

única diferencia es que las cantidades de productos son ordenadas de menor
a mayor.

6
 Ilustración 8.Orden por cantidades de menor a mayor

 Función buscar():

La función buscar() es del tipo void y recibe el arreglo del tipo Producto. Lo
que hace la función es pedir que el usuario introduzca el nombre del producto
a buscar. La función recibe la cadena digitada, transformándola a mayúsculas
para después hacer una comparación utilizando la función strcmp(). Para
hacer la comparación, se usó un ciclo do…while. Mientras el valor de la
comparación no sea igual a cero y el número de iteraciones sea menor que
la cantidad de productos (cinco), el ciclo no se rompe. Caso el valor de la
función strcmp() sea cero o el número de iteraciones sobrepasar la cantidad
de productos, el ciclo se termina. Si strcmp() continua diferente de cero y las
iteraciones sean superiores a cinco, la función buscar() regresa el mensaje
“Producto no encontrado!”. Caso strcmp() sea igual a cero, quiere decir que
las cadenas son iguales y se muestra el producto, con su precio y cantidad.
Como manipulación del número de iteraciones, se tiene que restar una
iteración para que el valor de la posición en la lista sea el correcto.

Ilustración 9. Producto no encontrado!

7
 Ilustración 10. Funcion buscar()

 Función mostrar_prod():

La función mostrar_prod() es del tipo void y recibe dos valores: el arreglo tipo
Producto y un valor tipo int. El valor entero es referente a la posición del
producto en el arreglo. La función nada más muestra en pantalla el producto
con su valor y cantidad. Para mostrar el precio con dos decimales se optó por
usar la función printf() con los términos %.2f señalando a la función que se
debe tomar apenas dos dígitos del número introducido.

 Función mostrar_todo():

Por último, la función mostrar_todo() se refiere a todo el arreglo. La función

utiliza un ciclo for para recorrer todo el arreglo y muestra todos los elementos
presentes en él. Es una función del tipo void y recibe un arreglo del tipo
Producto.

3. CÓDIGO EM C++

A continuación se mostrará el código de la solución presentada.

#include <iostream.h>
#include <conio.h>
#include <string.h>
#include <ctype.h>
#define CCP 30

8
#define CP 5

typedef struct
{
char np[CCP];
float p;
int ctd;
}Producto;

int menu(void);
void llenar_inv(Producto []);
void ord_np(Producto []);
void ord_p(Producto []);
void ord_ctd(Producto []);
void buscar(Producto[]);
void mostrar_prod(Producto [], int);
void mostrar_todo(Producto []);

void main(void)
{
int op, b1=0;
Producto l[CP];
do
{
op=menu();
switch (op)
{
case 1:
llenar_inv(l);
mostrar_todo(l);
b1=1;
break;

case 2:
if (b1)
{

9
 ord_np(l);
mostrar_todo(l);
}
else
{
cout<<"Llenar el inventario!";
}
break;

case 3:
if (b1)
{
ord_p(l);
mostrar_todo(l);
}
else
{
cout<<"Llenar el inventario!";
}
break;

case 4:
if (b1)
{
ord_ctd(l);
mostrar_todo(l);
}
else
{
cout<<"Llenar el inventario!";
}
break;

case 5:
if (b1)
{

10
 buscar(l);
}
else
{
cout<<"Llenar el inventario!";
}
break;

case 6:
break;

default:
cout<<"Opcion invalida!";
break;
}
getch();
clrscr();

}while(op!=6);
}

int menu(void)
{
int op;
cout<<"MENU\n1. Llenar el inventario;\n2. Ordenar el inventario
por nombre de producto;\n3. Ordenar el inventario por precio;\n4. Ordenar
el inventario por cantidad de productos;\n5. Buscar un nombre de
producto;\n6. Salir;\nOpcion: ";
cin>>op;
return op;
}

void llenar_inv(Producto a[])

{
for (int i=0;i<CP;i++)
{
cout<<"PRODUCTO "<<i+1;

11
 fflush(stdin);
cout<<"\nNombre: ";
cin.get(a[i].np,CCP-1,'\n');
int len=strlen(a[i].np);
for (int j=0;j<len;j++)
{
a[i].np[j]=toupper(a[i].np[j]);
}
do
{
cout<<"Precio: $ ";
cin>>a[i].p;
}while(a[i].p<0);
do
{
cout<<"Cantidad: ";
cin>>a[i].ctd;
}while(a[i].ctd<0);
clrscr();
}
}

void ord_np(Producto a[])

{
Producto aux;
for (int i=0;i<CP-1;i++)
{
for (int j=0;j<CP-1;j++)
{
if(strcmp(a[j].np, a[j+1].np)>0)
{
aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
}
}

12
 }
}

void ord_p(Producto a[])

{
Producto aux;
for (int i=0;i<CP-1;i++)
{
for (int j=0;j<CP-1;j++)
{
if(a[j].p<a[j+1].p)
{
aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
}
}
}
}

void ord_ctd(Producto a[])

{
Producto aux;
for (int i=0;i<CP-1;i++)
{
for (int j=0;j<CP-1;j++)
{
if(a[j].ctd>a[j+1].ctd)
{
aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
}
}
}
}

13
void buscar(Producto a[])
{
char b[CCP];
int resp, i=0;
fflush(stdin);
cout<<"BUSCAR PRODUCTO\nNOMBRE: ";
cin.get(b,CCP-1,'\n');
int len=strlen(b);
for (int j=0;j<len;j++)
{
b[j]=toupper(b[j]);
}

do
{
resp=strcmp(a[i].np, b);
i++;
}while(resp!=0 && i<CP);
if (i>=CP && resp!=0)
{
cout<<"Producto no encontrado!";
}
else
{
i--;
mostrar_prod(a,i);
}

void mostrar_prod(Producto a[], int b)

{
cout<<"NOMBRE: "<<a[b].np<<endl;
printf("PRECIO: $ %.2f",a[b].p);

14
 cout<<endl;
cout<<"CANTIDAD: "<<a[b].ctd<<endl;
}
void mostrar_todo(Producto a[])
{
for (int i=0;i<CP;i++)
{
cout<<"NOMBRE: "<<a[i].np<<endl;
printf("PRECIO: $ %.2f",a[i].p);
cout<<endl;
cout<<"CANTIDAD: "<<a[i].ctd<<endl;
cout<<endl;
}
}

4. CONCLUSIÓN

El programa utilizó el concepto de estructuras de datos. La funcionalidad en un

programa que utiliza esto aumenta considerablemente, puesto que se pueden
agregar datos en la estructura de datos y el programa gana nuevas
funcionalidades.

Otra facilidad que el programa ofrece es poder cambiar el número de caracteres

del nombre de los productos, así como el número de productos a ser ingresados.

15