PROGRAMACIÓN VISUAL

REPORTE DE PRÁCTICA #4

Alumno: Marcus André Menegatti da Costa

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

Torreón, Coahuila, 07/10/2022

Semestre: 04.2022
Índice
1. INTRODUCCIÓN ..................................................................................................................... 2
2. ANÁLISIS ................................................................................................................................ 2
 Función main(): ................................................................................................................. 3
 Función menu(): ................................................................................................................ 5
 Constructor Inventario():................................................................................................... 5
 Método llenar_inv(): ......................................................................................................... 5
 Método mostrar_inventario(): .......................................................................................... 6
 Método cargar_inventario(): ............................................................................................. 7
 Método guardar_inventario(): .......................................................................................... 8
 Método ord_np():.............................................................................................................. 9
 Método ord_p():.............................................................................................................. 10
 Método ord_ctd():........................................................................................................... 10
 Método buscar():............................................................................................................. 11
 Método mostrar_prod(): ................................................................................................. 12
 Método mostrar_todo(): ................................................................................................. 12
3. CÓDIGO EM C++ .................................................................................................................. 12
4. CONCLUSIÓN ....................................................................................................................... 22

Tabla de Ilustraciones
Ilustración 1. Menu ....................................................................................................................... 4
Ilustración 2. Opción Inválida ........................................................................................................ 4
Ilustración 3. Llenar el inventario o cargar el archivo ................................................................... 5
Ilustración 4. Transformación a mayúsculas ................................................................................. 6
Ilustración 5. Llenar inventario ..................................................................................................... 6
Ilustración 6. Mostrar Inventario .................................................................................................. 7
Ilustración 7. Archivo cargado con éxito! ...................................................................................... 8
Ilustración 8. Archivo guardado con éxito! ................................................................................... 9
Ilustración 9. Archivo "inventario.txt"........................................................................................... 9
Ilustración 10. Orden alfabético .................................................................................................. 10
Ilustración 11. Orden de precio de mayor a menor .................................................................... 10
Ilustración 12.Orden por cantidades de menor a mayor ............................................................ 11
Ilustración 13. Producto no encontrado! .................................................................................... 11
Ilustración 14. Funcion buscar() .................................................................................................. 12
 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, que sea capaz de utilizar una
estructura de datos para registrar un inventario, con nombre de cinco productos,
su precio y cantidad y que use el concepto de clases. El programa deberá
guardar y cargar un archivo, además de mostrarlo en pantalla.

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 no negativo para la cantidad de producto.

Se declarará y se utilizará una clase llamada Inventario. La estructura de datos,

llamada Producto, será un dato miembro de la clase.

El constructor de la clase tendrá la función de inicializar los datos p (precio) y c

(cantidad) de Producto a cero; el nombre del producto np será inicializado sin
caracteres.

El archivo generado llevará el nombre “inventario.txt ”, en modo texto.

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 clases.

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

2
cadena, para el nombre de los productos, un tipo flotante, para el precio, y un
tipo entero, para la cantidad de productos.

Además, será utilizada la clase Inventario que tendrá como variables privadas
un arreglo del tipo Producto y las variables b3, i, j, le, resp.

La función utilizada en el programa es: menu(). Ademas, fue usada la función

principal: main().

Para la clase, fueron utilizados los siguientes métodos: llenar_inv(),

mostrar_inventario(), cargar_inventario(), guardar_inventario(), ord_np(),
ord_p(), ord_ctd(), buscar(), mostrar_prod(), mostrar_todo().

Además de los métodos, fue usado un constructor que lleva el mismo nombre de
la clase, que inicializa los datos p (precio) y c (cantidad) de Producto a cero y el
nombre del producto np sin caracteres.

 Función main():

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

Antes de trabajar con los métodos de la clase Inventario, se hace la llamada

a esta clase y se utiliza el nombre Inv. También son declarados cuatro
números enteros: un para la opción del menú y los demás para que sean
“banderas”, que permiten el acceso determinadas opciones del menú.

La función principal está formada por todos los métodos de las clase
Inventario, anteriormente mencionados. 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

3
evaluar cada opción del número uno al nueve. 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ó dos variables de control, b1 y b2. Estas
variables son banderas que permiten 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, guardar el inventario y mostrarlo en
pantalla. Por esto, la variable b1 recibió un valor falso (el cero). Al llenar el
inventario, el valor de b1 cambia a verdadero (1) y permite generar todas las
demás opciones.

La misma función tiene b2. Sin embargo, esta variable está ligada a la opción
“cargar el inventario de un archivo”. Si se carga un archivo, la variable de
control pasará de un cero a uno (valor verdadero). Una vez cargado el
archivo, las opciones que muestra, guarda, ordena y busca un nombre de
producto se activarán.

Caso el inventario no sea llenado o no sea cargado ningún archivo, esas

funciones permanecerán con el valor b1 o b2 falsos y regresarán el mensaje:
“Llenar el inventario o cargar el archivo!”.

4
 Ilustración 3. Llenar el inventario o cargar el archivo

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.

 Constructor Inventario():

El constructor utiliza un ciclo for para inicializar los datos p (precio) y c

(cantidad) de Producto a cero y el nombre del producto np sin caracteres.

 Método llenar_inv():

El método llenar_inv() tiene como objetivo justamente llenar el inventario. Es

formada por un ciclo for. El argumento de la función es el objeto a 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

5
el nombre del producto, la función transforma los caracteres, cualesquiera
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

 Método mostrar_inventario():

La función mostrar_inventario() está compuesta de la función

cargar_inventario(), de la estructura selectiva if…else y del ciclo for. Más
adelante se explicará la funcionalidad de cargar_inventario(); sin embargo,
esta función genera un valor entero que, si verdadero (o igual a uno), permite
que la función mostrar_inventario() imprima en pantalla el contenido del
archivo “inventario.txt ” . Si negativo, la función no hace nada.

El método no recibe ningún valor y es del tipo void.

6
 Ilustración 6. Mostrar Inventario

 Método cargar_inventario():

El método cargar_inventario() es del tipo void y genera un valor entero, que

es una variable de control para la función mostrar_inventario(), como
explicitado en el punto anterior.

Para empezar el método, es generado un objeto f de la clase fstream, que irá

recibir o enviar datos a un archivo. En otras palabras, la clase fstream permite
la lectura y escritura de archivos de forma automática.

Para este método se utilizó una variable de control b, que regresará un cero
caso el programa no pueda leer el archivo (en caso de que tenga otro nombre
o que simplemente no esté en la debida carpeta). Para esto se utilizó la
función is_open() juntamente con un if…else, que evalúa si fue encontrado el
archivo o no. Si is_open() es igual a cero, el archivo no fue encontrado; caso
contrario, la bandera b cambia el valor a 1.

Caso el archivo no sea encontrado, aparecerá en pantalla el mensaje

“Archivo no encontrado!”. Esto hará que la función mostrar_inventario() no
realice ninguna acción.

Caso contrario, es decir, si el archivo fue encontrado, el objeto f hará la lectura

del archivo y asignará a cada elemento de la estructura de datos Producto
los datos contenidos en el archivo. Para leer y asignar los valores, fue usado
el ciclo for. Terminado el método, en el programa aparecerá el mensaje
“Archivo cargado con éxito!”.

Para que el programa lea los espacios entre palabras al cargar un archivo,
fue utilizada la función f.get(). La función está compuesta por tres

7
argumentos. El primero es la variable a ser leída, el segundo es la cantidad
de caracteres que puede tener la cadena y el tercero es el indicador de
cuando termina la cadena. En el caso específico del programa, los
argumentos son: a[i].np que es el nombre del producto en el arreglo de la
variable a tipo Producto, o sea, la primera información de la línea del archivo
será almacenada en a[i].np; el segundo argumento es CCP-1, que es la
cantidad de caracteres del nombre del producto; y el tercero es el indicador
de cuando termina la cadena, o sea, ‘\t’. En el caso del archivo, el nombre del
producto, el precio y la cantidad están separados por un tabulador. Es por
este motivo que se usó un tabulador como indicador de fin de cadena. Como
el tabulador es considerado un caracter, la cantidad de caracteres del nombre
del producto debe ser CCP-1.

Terminadas las instrucciones, el objeto f cerrará el archivo.

Ilustración 7. Archivo cargado con éxito!

 Método guardar_inventario():

El método guardar_inventario() es del tipo void y no recibe ningún dato. De la

misma manera que la función anterior, se usó la clase fstream y el objeto f
para escriturar un archivo. La función open() genera el archivo texto
“inventario.txt ”. Para hacer la escrituración, se utiliza el ciclo for. Se utilizó
el tabulador “\t” para separar las informaciones de manera igual.

Al terminar el ciclo, el mensaje “Archivo guardado con éxito!” es exhibido en

pantalla, indicando que el proceso fue correcto.

Al terminar las instrucciones, el objeto f cierra el archivo.

8
 Ilustración 8. Archivo guardado con éxito!

Ilustración 9. Archivo "inventario.txt"

 Método ord_np():

Para el método ord_n() se utilizó el tipo void y que no recibe nada. Lo que
hace la función es ordenar por orden alfabético, de la A hasta la Z, analizando
caracter por caracter. El método es compuesto 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 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.

9
 Ilustración 10. Orden alfabético

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

 Método ord_p():

El método ord_p() hace exactamente lo mismo que el método ord_np(), con

la diferencia que el primero 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 11. Orden de precio de mayor a menor

 Método ord_ctd():

El método ord_ctd() funciona de la misma manera que los métodos

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

10
 Ilustración 12.Orden por cantidades de menor a mayor

 Método buscar():

El método buscar() es del tipo void y no recibe ningún dato. Lo que hace el
método es pedir que el usuario introduzca el nombre del producto a buscar.
El método 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 13. Producto no encontrado!

11
 Ilustración 14. Funcion buscar()

 Método mostrar_prod():

El método mostrar_prod() es del tipo void y recibe un valor tipo int. El valor
entero es referente a la posición del producto en el arreglo. El método 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. El método no es necesario para el programa, puesto que
nada más es usado en el método buscar() y puede ser cambiado por las
instrucciones que lleva adentro.

 Método mostrar_todo():

Por último, el método mostrar_todo() se refiere a todo el arreglo. Este método

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 no recibe nada.

3. CÓDIGO EM C++

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

#include <iostream.h>
#include <fstream.h>
#include <stdio.h>
#include <conio.h>

12
#include <string.h>
#include <ctype.h>
#define CCP 30
#define CP 5

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

int menu(void);

class Inventario
{
private:
Producto a[CP];
int b3, i, j, le, resp;

public:
Inventario(void);
void llenar_inv(void);
void mostrar_inventario(void);
void cargar_inventario(int);
void guardar_inventario(void);
void ord_np(void);
void ord_p(void);
void ord_ctd(void);
void buscar(void);
void mostrar_prod(int);
void mostrar_todo(void);
};

Inventario::Inventario(void)
{

13
 for(i=0;i<CP;i++)
{
a[i].np[0]='\0';
a[i].p=0;
a[i].c=0;
}
}

void Inventario::llenar_inv(void)
{
for(i=0;i<CP;i++)
{
clrscr();
cout<<"PRODUCTO "<<i+1;
fflush(stdin);
cout<<"\nNOMBRE DEL PRODUCTO: ";
cin.get(a[i].np,CCP-1,'\n');
le=strlen(a[i].np);
for(j=0;j<le;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].c;
}while(a[i].c<=0);
clrscr();
}
}

14
void Inventario::mostrar_inventario(void)
{
cargar_inventario(b3);
if (b3==0)
{
}
else
{
cout<<endl<<endl;
for(i=0;i<CP;i++)
{
cout<<a[i].np<<"\t"<<a[i].p<<"\t"<<a[i].c;
cout<<endl;
}
}
}

void Inventario:: cargar_inventario(int b)

{
fstream f;
b=0;

f.open("Inventario.txt",ios::in);
if (f.is_open()==0)
{
cout<<"No se cargo el archivo!";
}
else
{
for(i=0;i<CP;i++)
{
f.get(a[i].np,CCP-1,'\t');
f>>a[i].p;
f>>a[i].c;
}
b=1;

15
 }
f.close();
}

void Inventario::guardar_inventario(void)
{
fstream f;

f.open("Inventario.txt",ios::out);
for(i=0;i<CP;i++)
{
f<<a[i].np<<"\t"<<a[i].p<<"\t"<<a[i].c;
}
cout<<"Archivo guardado con exito!";
f.close();
}

void Inventario::ord_np(void)
{
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;
}
}
}
}

void Inventario::ord_p(void)
{

16
 Producto aux;
for(i=0;i<CP-1;i++)
{
for(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 Inventario::ord_ctd(void)
{
Producto aux;
for(i=0;i<CP-1;i++)
{
for(j=0;j<CP-1;j++)
{
if(a[j].c>a[j+1].c)
{
aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
}
}
}
}

void Inventario::buscar(void)
{
char b[CCP];
i=0;

17
 cout<<"BUSCAR PRODUCTO"<<endl;
cout<<"NOMBRE: ";
fflush(stdin);
cin.get(b,CCP-1,'\n');
le=strlen(b);
for(j=0;j<le;j++)
{
b[j]=toupper(b[j]);
}
do
{
resp=strcmp(a[i].np,b);
i++;
}while(i<CP && resp!=0);
if (i>=CP && resp!=0)
{
cout<<"Producto no encontrado!";
}
else
{
i--;
mostrar_prod(i);
}
}

void Inventario::mostrar_prod(int b)
{
cout<<"NOMBRE: "<<a[b].np<<endl;
printf("PRECIO: $ %.2f",a[b].p);
cout<<endl;
cout<<"CANTIDAD: "<<a[b].c<<endl;
}

void Inventario::mostrar_todo(void)
{
cout<<endl;

18
 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].c<<endl;
cout<<endl;
}
}

void main(void)
{
int op, b1=0, b2=0, b3;
Inventario Inv;
do
{
op=menu();
switch (op)
{
case 1:
Inv.llenar_inv();
Inv.mostrar_todo();
b1=1;
break;

case 2:
if(b1||b2)
{
Inv.mostrar_inventario();
}
else
{
cout<<"Llenar el inventario o cargar
el archivo!!";
}
break;

19
 case 3:
Inv.cargar_inventario(b3);
cout<<"Archivo cargado con exito!";
b2=1;
break;

case 4:
if (b1||b2)
{
Inv.guardar_inventario();
}
else
{
cout<<"Llenar el inventario o cargar
el archivo!!";
}
break;

case 5:
if (b1 || b2)
{
Inv.ord_np();
Inv.mostrar_todo();
}
else
{
cout<<"Llenar el inventario o cargar el
archivo!";
}
break;

case 6:
if (b1 || b2)
{
Inv.ord_p();
Inv.mostrar_todo();
}

20
 else
{
cout<<"Llenar el inventario o cargar el
archivo!";
}
break;

case 7:
if (b1 || b2)
{
Inv.ord_ctd();
Inv.mostrar_todo();
}
else
{
cout<<"Llenar el inventario o cargar el
archivo!";
}
break;

case 8:
if (b1 || b2)
{
Inv.buscar();
}
else
{
cout<<"Llenar el inventario o cargar el
archivo!";
}
break;

case 9:
break;

default:
cout<<"Opcion invalida!";

21
 break;
}
getch();
clrscr();

}while(op!=9);
}

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

4. CONCLUSIÓN

El programa utilizó el concepto de clases y 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 en la clase.

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.
Además, ahora se puede generar un archivo tipo texto para almacenar la
información generada por el programa y accederla cuando sea necesario.

22