INDICE

1. INTRODUCCIÓN………………………………3

2. ANÁLISIS………………………………………4

3. DIAGRAMA DE FLUJO………………………5

4. CÓDIGO (C++)…………………………………10

5. CAPTURA DE PANTALLA EN EJECUCIÓN…17

6. CONCLUSIONES INDIVIDUALES…………19

2
 Introducción

El tema de este proyecto son los diagramas de flujo y los programas hechos en C++. ¿Y que
son los diagramas de flujo? Un diagrama de flujo es una representación gráfica de un proceso.
Cada paso del proceso es representado por un símbolo diferente que contiene una breve
descripción de la etapa de proceso.
¿Para qué usarlos? Los programadores usan diagramas de flujo de datos para identificar
dónde se originan los mismos, dónde están siendo alterados, y dónde se almacenan. Estos
diagramas suelen ser lineales y se leen de izquierda a derecha. Se le pueden agregar columnas
para indicar los tiempos de tareas y otros eventos para que puedas examinar las tareas dentro
del proceso con respecto al tiempo. Un diagrama de flujo con columnas de sincronización es
útil para tareas y procesos orientados a una fecha límite; ilustra las áreas donde las tareas
necesitan hacerse más eficientes, o las áreas que están en espera de la realización de otras
tareas.
Ahora, ¿qué es C++? C++ es un lenguaje de programación diseñado a mediados de los años
1980 por Bjarne Stroustrup. La intención de su creación fue el extender al lenguaje de
programación C mecanismos que permiten la manipulación de objetos. En ese sentido, desde
el punto de vista de los lenguajes orientados a objetos, C++ es un lenguaje híbrido.
Posteriormente se añadieron facilidades de programación genérica, que se sumaron a los
paradigmas de programación estructurada y programación orientada a objetos. Por esto se
suele decir que el C++ es un lenguaje de programación multiparadigma.
¿Por qué hicimos este proyecto? Este proyecto lo hicimos ya que aquí es donde podemos
poner en práctica todo lo que hemos aprendido durante el semestre, como las funciones de
switch, for, los vectores, matrices, etc. Todo para hacer un programa de un restaurante.
En este programa podemos ver los diferentes precios de las comidas, bebidas, etc.
Seleccionar cualquiera de ellas y comprarlas, al comprarlas te saldrá el precio de cada una,
luego el total a pagar. Al final te saldrá una opción de que si quieres seguir comprando o
acabar con tu orden. También incluirá el sistema de cambio en efectivo, para calcular de
inmediato el vuelto de la persona o el vuelto de la empresa al cliente.
Algunas de las estructuras de programación que se utilizarán son switch, while, for, if/else.
Utilizaremos igualmente estructuras en el mismo lenguaje, C++, para facilitar la declaración
de productos del restaurante. La finalidad del proyecto mismo es comenzar a visualizar todo
lo que un restaurante o una empresa conlleva en su sistema y que tan fácil o que tan difícil
puede ser. Igualmente, uno de los objetivos principales y no tan secundarios del proyecto es
mejorar la calidad de programación que cada uno de los desarrolladores de este proyecto
tiene. Sin más preámbulo.

3
 Análisis

Entender el problema.
El tema que nos toco es sobre un restaurante, en donde tenemos que mostrarle al usuario el
menú de los productos con los que cuenta nuestro restaurante ficticio, así como también con
sus respectivos datos (el precio del producto, la cantidad del producto que escogió, etc.) e
imprimir la cuneta final que debe de pagar el cliente.
Configurar un plan
Por medio de “DEV C++” vamos a codificar el programa para hacer una factura con los datos
que el usuario introduzca, utilizaremos funciones de C++, vectores y estructuras para hacer
funcionar el programa correctamente. El programa comenzará solicitando al usuario que
alimento desea consumir y después la cantidad de estos, posteriormente con esos datos se
formularan operaciones para sumar el precio de cada producto seleccionado y obtener la
cuenta total a pagar. Para terminar la orden del cliente, tendremos la opción de salir y te
arrojara la cuenta del cliente para poder tomarle la orden al cliente que siga. Incluirá un
algoritmo para detectar el efectivo del cliente, en su defecto el cambio que se le tendrá que
dar o el resto faltante del mismo cliente. Se podrá abortar la orden si se desea.
Ejecutar el plan
Una vez establecido un plan solamente es cuestión de llevarlo a cabo, implementamos un
menú donde el usuario pueda escoger los siguientes alimentos: enchiladas, hamburguesas,
burritos y pizzas. Creamos una función la cual va a depender del producto que escoja, se
harían las operaciones debidas, cuando el cliente termine de elegir su orden, el programa le
mostrara su factura de todos los productos que ordeno, el precio unitario, el precio por la
cantidad solicitada y el total de toda su compra.
Comprobar resultados
Los resultados fueron buenos, logramos conseguir que el programa funcionara correctamente
y que imprimiera la factura, los vectores fueron útiles y no salió ningún error, el propósito
del programa era hacer un menú y con esos datos dar el total del precio a pagar.

CONCLUSION DEL ANALISIS

Gracias al análisis que realizamos con anterioridad ya podemos realizar correctamente el
programa establecido, no tuvimos muchas complicaciones ya que conocíamos sobre el tipo
de datos que debemos ingresar al igual que la estructura que debe de llevar el código para
que pueda ejecutar sin errores.

4
DIAGRAMA DE FLUJO

5
6
7
8
VISTA GENERAL DEL DIAGRAMA DE FLUJO (GENERADO EN SOFTWARE
‘’DIA’’)

9
CODIGO (C++)

10
#include <iostream> //INPUT OUTPUD CODE
#include <iomanip> //SETW (TABLITAS)
#include <stdlib.h> //STANDARD LIBRARY
#include <string> //SETW
#include <string.h> //SETW
#include <windows.h> //COLORES, TITULOS, SLEEP
#define COLOR_INICIO system("color A") //COLOR VERDE
#define COLOR_ERROR system("color 5") //COLOR MORADO DE ALTERA

using namespace std; //STD::COUT STD::ENDL

void getMenu(); //OBTENER EL MENU DE LA ESTRUCTURA PRODUCTO

struct Producto{ //''OBJETO'' DE PRODUCTO

string id;
string nombre;
float precio;
};

const int productos = 25; //LA TIENDA TIENE 25 PRODUCTOS :D

Producto p[productos]={
{"001"," ENCHILADAS ", 50 },
{"002"," FLAUTAS ", 100},
{"003"," PIZZA ", 130},
{"004"," BURRITO ", 30},
{"005"," POZOLE ", 90},
{"006"," GORDITAS ", 30},
{"007"," SODA ", 20},
{"008"," CERVEZA ", 30},
{"009"," LASANA ", 80},
{"010","AGUA ", 20},
{"011","TACOS ", 100},
{"012","HAMBURGUESAS ", 100},
{"013","QUESADILLAS ", 80.50},
{"014","COCTEL DE CAMARON ", 300},
{"015","FILETE G ", 259.99},
{"016","FILETE CH ", 139.99},
{"017","CAFE ", 30},
{"018","JUGO DE NARANJA ", 20},
{"019","GELATINA ", 40},
{"020","REB. PASTEL ", 35},
{"021","CUPCAKES ", 15},
{"022","HELADO ", 20},
{"023","YOGURTH C/FRUTA ", 50},
{"024","LICUADOS ", 25.80},

11
 {"025","HOT DOGS ", 50}
};
int main(void){
system("title RESTAURANTE V 4.0");
int contador = 0; //COUNTER
int u = 0; //COUNTER
float a,b; //RESTOS VUELTOS
float dinero; //INGRESAR DINERO
char opD; //OP
float suma = 0; //SUMA DE $
string idP; //AQUI ALMACENO LOS IDS
string prueba[1000]; //VECTOR LIMITADO A 1000 PRODUCTOS POR
PERSONA.
COLOR_INICIO; //DECLARACION
char op; //OP

cout<<setw(80)<<"|-------------------------------------------
------|"<<endl;
cout<<setw(57)<<"MENU"<<endl;
cout<<setw(80)<<"|--------------------------------------------
-----|"<<endl;
for(int i=0; i<productos; i++){
cout<<setw(40)<<"[0"<<i+1<<"]"<<"
"<<p[i].nombre<<setw(5)<<"$"<<p[i].precio<<endl;
}
cout<<endl;
cout<<setw(80)<<"|-------------------------------------------
------|"<<endl;
cout<<setw(65)<<"[A] GENERAR ORDEN"<<endl;
cout<<setw(65)<<"[B] SALIR "<<endl;
cout<<setw(80)<<"|--------------------------------------------
-----|"<<endl<<endl;
cout<<setw(80)<<"
"; cin>>op;

g: //GOTO G SI SE EQUIVOCA
switch(op){ //SWITCH GRANDE
case 'A':
char op2;
system("cls");
cout<<setw(80)<<"|-------------------------------------------
------|"<<endl;
cout<<setw(65)<<"[A] AGREGAR "<<endl;
cout<<setw(65)<<"[X] CANCELAR "<<endl;
cout<<setw(65)<<"[Q] TERMINAR "<<endl;
cout<<setw(80)<<"|-------------------------------------------

12
------|"<<endl<<endl;
cout<<setw(80)<<"
"; cin>>op2;

switch(op2){ //MEDIANO
case 'A':
getMenu();
cout<<endl;
cout<<setw(80)<<"|--------------------------------
-----------------|"<<endl;
while(true){
//WHILE 1 SE GENERA TODO Y SE CORTA EN LA LINEA 109 CON UN
BREAK;
cout<<u+1<<" | ID"<<endl;
cin>>idP;
prueba[contador] = idP;
contador++;
u++;
//ALGORITMO PARA GENERAR LA NOTA
if(idP=="Q" || idP=="q"){
for(int i=0; i<contador-1; i++){
for(int j=0; j<productos; ++j){
if(prueba[i]==p[j].id){
suma = suma + p[j].precio;

cout<<setw(40)<<"["<<prueba[i]<<"]"<<setw(5)<<""<<p[j].nombre
<<setw(5)<<"$"<<p[j].precio<<endl;

}
}
}
break;
}
//AQUI PASA SI SE OPRIME X SE CANCELA TODO
if(idP=="X" || idP=="x"){
cout<<setw(80)<<"|--------------------------------------
-----------|"<<endl;
cout<<setw(65)<<"ORDEN CANCELADA :("<<endl;
cout<<setw(80)<<"|--------------------------------------
-----------|"<<endl;
main();
}
} //FIN WHILE

while(suma>0){
cout<<endl;

13
cout<<setw(80)<<"|------------------------------------------------
-|"<<endl;
cout<<setw(65)<<"EL TOTAL DE LA COMPRA ES DE $"<<suma<<endl;
cout<<setw(65)<<"INGRESE EL DINERO DEL CLIENTE: "; cin>>dinero;
cout<<setw(80)<<"|------------------------------------------------
-|"<<endl;
if(dinero>suma){
a = dinero - suma;
system("cls");
cout<<setw(80)<<"|-------------------------------------------
------|"<<endl;
cout<<setw(63)<<"EL CAMBIO ES DE $"<<a<<endl;
cout<<setw(80)<<"|-------------------------------------------
------|"<<endl<<endl;
Sleep(1000);
cin.get();
main();
}else if(suma>dinero){
b = suma - dinero;
x:
COLOR_ERROR;
cout<<setw(80)<<"|-------------------------------------------
------|"<<endl;
cout<<setw(65)<<"AL CLIENTE LE FALTAN $"<<b<<endl;
cout<<setw(65)<<"EL DINERO FUE RECIBIDO? Y/N"<<endl;
cout<<setw(80)<<"|-------------------------------------------
------|"<<endl;
cin>>opD;
switch(opD){ //INICIO SUB SWITCH
case 'Y':
memset(prueba, 0, sizeof prueba); //MEMSET ES UNA FUNCION
PARA 'CORTAR' LOS 'INGRESOS' DEL VECTOR PRODUCTOPRUEBA
system("cls");
cout<<setw(80)<<"|--------------------------------------
-----------|"<<endl;
cout<<"
ORDEN EXITOSA. PROCESANDO CAMBIOS"<<endl;
cout<<setw(80)<<"|---------------------------
----------------------|"<<endl;
Sleep(5000);
main();
break;
case 'N':
system("cls");
cout<<setw(80)<<"|---------------------------
----------------------|"<<endl;

14
 cout<<"
LA ORDEN FUE CANCELADA POR EL ADM"<<endl;
cout<<setw(80)<<"|---------------------------
----------------------|"<<endl;
Sleep(5000);
system("cls");
main();
break;
default:
goto x;
break;
} //FIN SUB SWITCH
} else if(dinero=suma){
cout<<setw(80)<<"|-------------------------------------------
------|"<<endl;
cout<<setw(67)<<" CUENTA PAGADA GRACIAS!"<<endl;
cout<<setw(67)<<"PROCESANDO CAMBIOS....."<<endl;
cout<<setw(80)<<"|-------------------------------------------
------|"<<endl;
Sleep(2000);
system("cls");
main();
}
}
cout<<setw(80)<<"|------------------------------------------------
-|"<<endl;
cout<<" HA OCURRIDO UN
ERROR INESPERADO!"<<endl;
cout<<setw(80)<<"|------------------------------------------------
-|"<<endl;
case 'X':
cout<<setw(40)<<"
ORDEN CANCELADA :("<<endl<<endl;
main();
break;

default:
goto g;
break;

} //MEDIANO
break;
case 'B':
system("cls");
cout<<setw(80)<<"|--------------------------------------

15
-----------|"<<endl;
cout<<setw(76)<<"GRACIAS POR USAR EL SISTEMA. HASTA
LUEGO!!"<<endl;
cout<<setw(80)<<"|--------------------------------------
-----------|"<<endl;
exit(0);
cin.get();
break;
default:
system("cls");
main();
break;
} //SWITCH GRANDE
return 1; //1 PARA SABER SI TERMINO BIEN :D
}

//FUNCION PARA OBTENER EL MENU CUANDO INGRESAMOS UNA ORDEN :D

void getMenu(){
cout<<setw(80)<<"|--------------------------------------
-----------|"<<endl;
cout<<setw(57)<<"MENU"<<endl;
cout<<setw(80)<<"|--------------------------------------------
-----|"<<endl;
for(int i=0; i<productos; i++){
cout<<setw(40)<<"[ ]
"<<p[i].id<<setw(5)<<""<<p[i].nombre<<setw(5)<<"$"<<p[i].precio<<e
ndl;
}
}

16
CAPTURA DE PANTALLA

17
SE INGRESA 500 EN EL PEDIDO

18
CONCLUSIONES INDIVIDUALES

19
 Joahan Xavier Diaz Sánchez

Pues estos 4 meses de estar en la especialidad de programación fueron excelentes,

aunque fueron un poco estresantes con todos los trabajos que nos ponían. Lo que
aprendí fue mucho, ya que en mi vida había visto algo sobre programar. Desde que
empezamos se me hizo interesante todo porque puede parecer difícil, pero si te
gusta se hace todo más fácil.

Aprendimos desde crear simples programas en diagramas de flujo, hasta crear el

código de los programas. Vimos los diagramas secuenciales, que son los más
fáciles, luego llegamos a los de selección que estaban fáciles una vez que los
entendieras, vimos más cosas, luego ya ahorita al final llegaron los vectores, casi
no le entendí a esos, pero creo que leyendo un poco sobre ellos hará que le entienda
y no batallare.

Uno de mis logros más que nada era entrar en el mundo de los programadores o
ingenieros de sistemas ya que mis papás siempre han estado trabajando en
agencias aduanales, y siempre he querido ayudarlos, no tanto en su trabajo, pero
en los programas donde trabajan, porque muchas veces los programas que usan
fallan y así no pueden trabajar, así que siempre he pensado en que cuando sepa
más sobre esto, crear un programa para que alguna empresa de agencias
aduanales lo pueda usar o algo así.

Creo que aprender todo esto me ayudo en mi vida, ya que programación te ayuda
a ejercitar tu mente al tratar de resolver problemas porque te hace pensar y arreglar
las cosas.

20
 Martínez de Hoyos Jesús Orlando

Mi conclusión sobre este tema es que me ha gustado aplicar y ver todo lo aprendido
en el semestre y respecto a lo que pienso de esta especialidad es que es una
especialidad que me gusta y desde antes de conocerla también le llamaba la
atención pero es obvio que al escuchar programación te imaginas muchas otras
alternativas pero al ver lo que en verdad es, es muy entretenido aparte de estar
aprendiendo cosas, me gusta sentir esa sensación de emoción y que se va la
frustración al ver que de tantos errores por fin te salga, la programación creo que
me aportó un gran aprendizaje en este semestre y puedo decir que hasta más de lo
que teníamos que saber, pero también cabe añadir que no es todo lo que se puede
ver en programación esto sería como algo súper básico ya que por la programación
existen muchísimas funciones, y lenguajes los cuales no pudieras aprender en un
solo semestre.

La programación es muy interesante para resumir todo mi progreso sobre esta

especialidad en este semestre es básicamente de no saber nada y pensar al ver
tantas funciones pensar que difícil es esto, y hoy saber que eso difícil que pensaba
yo que era ,hoy en día se me sea muy sencillo, eso quiere decir que aprendí y eso
me pone muy contento ,creo que la programación me va a servir en algún futuro, de
alguna manera sé que este aprendizaje no será en vano , aunque no me dediqué a
eso en un futuro sé que el conocimiento estará ahí, sé que se vienen cosas más
difíciles pero solo hay un camino y eso y es aprender y trabajar para aprender ,
bueno eso es mi conclusión y sobre lo que pienso de la programación espero y les
haya sido de su agrado, voy por un camino de nuevos conocimientos.... Gracias.

21
 Rendón García Víctor Manuel

Este primer semestre en la especialidad de Técnico Programador fue mejor de lo

que esperaba, me enseñaron temas que me ayudaron tanto para entender mejor la
materia, así como también para desarrollar las actividades que realizamos día con
día, me mostró otra forma de ver cómo es que trabaja el mundo a mi alrededor;
realizamos instrucciones tan simples que no las notamos, y tales procesos son los
que hay que desarrollar al momento de programar, hay que describir paso a paso
todo lo que queremos que haga nuestro programa para que pueda funcionar como
queremos.

Las clase fueron completas y en algunas ocasiones divertidas, los trabajos fueron
un poco difíciles al principio, ya que no dominaba al 100% el tema del que trataban,
pero conforme fui practicando más y más ya los últimos ejercicio no eran tan
complicados, porque estaba estructurados con todos los temas anteriores, solo era
cuestión de acomodar y relacionar cada uno de ellos con lo que me solicitaban,
pase por algunas altas y bajas durante este periodo pero me fui adaptando a la
situación estudiando y mejorando mi capacidad de comprensión.

Me dejo una grata experiencia todo lo que aprendí estos últimos meses ya que serán
la base para poder superar todos los retos que están por venir, parecerá un poco
extraño pero cuando comencé codificar me gusto quemar neuronas en ver cuál era
el error que me marcaba el programa y sentía una gran satisfacción al encontrarlo,
pero la mayoría de las veces enojo porque era solo un punto y coma, pero bueno,
de los errores se aprende, todavía faltaron uno o dos temas por comprender pero
creo que estoy preparado para el siguiente semestre, voy a tratar de aumentar mis
conocimientos durante este periodo de vacaciones para no tener muchas
complicaciones iniciando el próximo semestre y reforzar los ya obtenidos.

22
 Peña Ortiz Alan

El primer semestre de programación no fue tan malo del todo aprendí detalles y
cosas que algún día necesitaré utilizar y no sabía con anterioridad. La pasé muy
bien trabajando en equipo, individualmente, y en conjunto con mi grupo. Me encantó
ir a laboratorio todos estos días, cada vez que tocaba horas de eso era un alivio
saber que iba a hacer algo que sé hacer y que me gusta hacer, y que gracias a ello
puedo resolver problemas y quemarme la cabeza un rato. Y a pesar de ello, de a
veces tomar tan profundo cada problema, los saqué delante de alguna forma, pero
lo hice, cuando trabajé en equipo traté de siempre distribuir el trabajo, y saber tomar
decisiones y soluciones en conjunto. C++ no fue en algún tiempo mi lenguaje
favorito ni el que por más apostara, sin embargo, aprendí que hay que saber de todo
un poco, de lo malo en la vida, de lo bueno, y, en clase, supe que era un excelente
lenguaje con muchas posibilidades, desde su hibridación hasta poder crear algunos
videojuegos. Programación está en todas partes, en cualquier lugar a donde
vayamos hay un programador detrás, un ingeniero en sistemas, un ingeniero en
software, un diseñador, etc., Como primera conclusión puedo decir hoy por hoy que
empiezo a formarme como programador, porque, aunque las personas digan que
es una carrera sencilla, realmente no lo es, y es que, sumar dos números lo puede
ser, crear un ejecutable que muestre tu nombre cien veces también, pero que hay
en un futuro, ¿qué hay de los sistemas enormes?, ¿de toda la gente que está detrás
de un ordenador, haciendo posible que yo este escribiendo en este momento esta
conclusión?, también son programadores, en mayor o menor medida. Puedo decir
que programación es la carrera que esperaba y realmente pienso que somos de las
personas que hacemos realidad cualquier cosa que se nos plantee, y en un futuro
con mayores bases podremos resolver millones de problemáticas, puesto que éstas
nunca se acabarán y cada día necesitarán la ayuda de uno. Este semestre le doy
un cien de diez, porque mi maestra enseñó lo que debía y fue paso a paso,

23
pacientemente, y con calma; creo que le dimos bastante estrés, como también ella
a nosotros, pero gracias a ello el día de mañana no batallaremos en nada y siempre
recordaremos todo lo que nos enseñó. Me encantó diseñar programas en consola,
hacer que se vieran colorcitos, diseñar patrones, algoritmos sencillos hasta
complejos, investigar funciones nuevas, agregar librerías, también me gustó
bastante la manera en que se planteaban los problemas, muy acorde a lo que
nosotros debemos ver en primer semestre. Concluyo con lo siguiente: este semestre
fue lo máximo y nunca lo olvidaré, y como dato casual, me divertí bastante.

24