Nombres:

Curso :

Gonzalo Castillo
Vctor Utreras
IGI - 3101

Observaciones
Se adjuntan dos versiones del programa en el Disco, una es para ser
compilada en el editor Dev-C++ y la otra versin es para ser compilada en
Visual-C++.
La nica diferencia radica en el uso de la librera para las funciones de pantalla.
Conio.h para Dev-C++ y VGLib.h para Visual-C++,Ya que las funciones entre
una versin y otra son levemente diferentes.
Constantes utilizadas
Para texcolor, textbackground, ColorTexto, CrearVentana,etc.
BLACK
BLUE
LIGHTRED
WHITE

0
1
12
15

//NEGRO
//AZUL MARINO
//ROJO CLARO
//BLANCO

Definidas en (Conio.h para Dev-C++, VGLib.h para Visual C++)

Pausa : permite hacer una pausa en el programa.
Estructura Utilizada
Fue utilizada como nodo para la lista enlazada, la cual permite guardar
Todas las transacciones ya sea giros, depsitos o saldos para cada caja. Esta
funciona de la siguiente forma:
El primer proceso es iniciar las cajas, en la cual se inicia solo el saldo
inicial de cada caja, luego cada vez que se realiza una transaccin se guarda el
valor de esa transaccin en las variables miembro de la estructura, si es giro se
guarda en DinSalida y si es deposito se guarda en DinEntrada, adems el
Saldo de cada caja se actualiza por cada transaccin, ejemplo:
Si en un momento se realiza un giro, se crea un nodo nuevo, se ingresa
el valor del giro y se guarda en la Variable DinSalida, luego para actualizar el
Saldo de la caja, se le resta al saldo del nodo anterior el valor que se guardo en
DinSalida. Luego tenemos que en el nodo creado se guardo el Saldo con el
que quedo la caja y el valor de la transaccin, adems se guarda el ID de la
caja para saber que caja es. Y asi es sucesivamente por cada transaccin que
se realice.
struct NodoCaja {
struct NodoCaja *sig;
Long Saldo;
Int Id;
Long DinSalida;
Long DinEntrada;
}

Variables Miembros:
Saldo : Guarda el saldo actual de la Caja.
Id
: Guarda la Identificacin de la Caja.
DinSalida
: Guarda el Giro (Solamente si es realizado)
DinEntrada : Guarda el Deposito (Solamente si es realizado)
*Sig
: Guarda la direccin del Nodo siguiente.
Punteros Globales Asociados a la Estructura
Punteros Cabeceras para cada Caja respectivamente:
*Caja1
*Caja2
*Caja3
Punteros Para Recorrer para cada caja respectivamente:
*fin1
*fin2
*fin3
Variables para Manejar y crear la cola
int ColaClientes[10] : Cola principal de Clientes. Si es 1 indica que esta.
ocupado y si es 0 indica que el puesto esta vaci.
int I : Es el ndice del primer cliente de la cola.
int F : Es el ndice del ultimo cliente de la cola.
int NumClientes :
int Acciones : Indica todas las transacciones efectuadas y Clientes atendidos.
Funciones Utilizadas
void IniciarCaja(): Permite crear el primer nodo para cada caja e iniciar el
primer Saldo para cada Caja.
void MenuPrincipal(): Muestra un men para atender al cliente.
void MenuAtender(): Muestra el men para realizar un giro o un deposito.
void HacerGiro(): Hace el proceso para realizar un giro, Crea un nodo nuevo y
lo enlaza de pendiendo de la caja.
void HacerDeposito(): Hace el proceso de realizar un deposito, Crea un nodo y
lo enlaza.
void IngresarCliente(): Hace el proceso de ingresar un Cliente a la Cola
(ColaClientes[ ]).

int RecorrerCola(): Determina la cantidad de clientes que contiene la cola.

void MostrarSaldoFinal(NodoCaja *aux): Recorre la estructura y muestra el
Saldo actual de cada caja.
void MostrarDepositos(NodoCaja *aux): Recorre la estructura y muestra la
cantidad de dinero de salida de cada caja.
void MostrarGiros(NodoCaja *aux): Recorre la estructura y muestra la cantidad
de dinero de entrada de cada caja.
void MostrarTotales(): Funcion que llama a las funciones para mostrar todos los
totales finales.
void CerrarCajas(): Permite Cerrar todas las cajas y llamar a la funcin
MostrarTotales() al final del programa.
void Salir(): Termina el programa y muestra los crditos.
inline void LimpiarVentana(): Borra la pantalla.
inline void Linea(const char *caracter): Dibuja una lnea para separar.
Algoritmo del programa
/********************************************************************
*
* Programado por: Gonzalo Castillo y Victor Utreras.
* Trabajo de Estructura de Datos.
* Programa que perimite Administrar una cola de clientes
* en un Banco.
* fecha: 1/06/2003.
*
*********************************************************************
*/
/* Version Dev-C++ */
#include <stdio.h>
#include <stdlib.h>
#include "conio.h"
#define Pausa getch();
/* Definicion de Estructuras */
struct NodoCaja{
struct NodoCaja *sig;
struct NodoCaja *Ant;
long Saldo;
int Id;
long DinSalida;
long DinEntrada;

} *Caja1=NULL,*Caja2=NULL,*Caja3=NULL,*fin1=NULL,*fin2=NULL,*fin3=NULL;
int NoGirar=0;
int ColaClientes[10]; /* 1- Ocupado */
int I=-1,F=-1; /* indices para la ColaClientes inicio y final Respectivamente*/
int NumClientes;
//int Cual;
int Acciones=0;
void IniciarCaja();
void MenuPrincipal();
void MenuAtender();
void HacerGiro();
void HacerDeposito();
void IngresarCliente();
int RecorrerCola();
void MostrarSaldoFinal(NodoCaja *aux);
void MostrarDepositos(NodoCaja *aux);
void MostrarGiros(NodoCaja *aux);
void MostrarTotales();
void CerrarCajas();
void Salir();
inline void LimpiarVentana() { clrscr(); }
inline void Linea(const char *caracter){
int x; printf("\n");
for(x=0;x<80;x++)printf(caracter);
}
/*******************************************************************
*
*
Funcion que permite Iniciar las Cajas.
*
********************************************************************
*/
void IniciarCaja(){
struct NodoCaja *auxCaja;
Linea("_");
printf("\n\t\t\t BANCO \n");
printf("\n\t\t\tIniciar Caja\n");
Linea("_");
printf("\t\t\n Iniciar Caja 1 : $ ");
auxCaja=(struct NodoCaja*)malloc(sizeof(struct NodoCaja));
scanf("%ld",&auxCaja->Saldo );
auxCaja->Id=1;
auxCaja->DinEntrada = 0;
auxCaja->DinSalida=0;
auxCaja->sig=NULL;
if (Caja1==NULL){
Caja1=auxCaja;
fin1=Caja1;
}
printf("\t\t\n Iniciar Caja 2 : $ ");
auxCaja=(struct NodoCaja*)malloc(sizeof(struct NodoCaja));
scanf("%ld",&auxCaja->Saldo);

auxCaja->Id=2;
auxCaja->DinEntrada=0;
auxCaja->DinSalida=0;
auxCaja->sig=NULL;
if (Caja2==NULL){
Caja2=auxCaja;
fin2=Caja2;
}
printf("\t\t\n Iniciar Caja 3 : $ ");
auxCaja=(struct NodoCaja*)malloc(sizeof(struct NodoCaja));
scanf("%ld",&auxCaja->Saldo);
auxCaja->Id=3;
auxCaja->DinEntrada=0;
auxCaja->DinSalida=0;
auxCaja->sig=NULL;
if (Caja3==NULL){
Caja3=auxCaja;
fin3=Caja3;
}
LimpiarVentana();
MenuPrincipal();
}
/*******************************************************************
*
*
Funcion que permite Cerrar las Cajas.
*
********************************************************************
*/
void CerrarCajas(){
int opcion=0;
while (opcion==0){
LimpiarVentana();
textcolor(BLUE);
Linea("_");
printf("\n\t\t\t BANCO \n");
printf("\n\t\t
Mostrar Totales \n");
Linea("_");
textcolor(LIGHTRED);
printf("\t\t\n Se han Atendido %d Clientes Y las Cajas Se Han Cerrado.",Acciones);
printf("\t\t\n Si desea ver los totales elija la Opcion 1.\n");
textcolor(BLUE);
printf("\t\t\n 1- Mostrar Totales");
printf("\t\t\n 2- Salir del Programa\n");
printf("\t\t\n Opcion :");
scanf("%d",&opcion);
}
switch (opcion){
case 1:MostrarTotales();
break;
case 2:Salir();
break;
default:CerrarCajas();

}
}
/*******************************************************************
*
*
Funcion para Mostrar el menu Principal.
*
********************************************************************
*/
void MenuPrincipal(){
int opcion=0;
while (opcion==0){
LimpiarVentana();
Linea("_");
printf("\n\t\t\t BANCO \n");
Linea("_");
//printf("I= %d \nF= %d",I,F);
printf("\t\t\n La Cola de Clientes Tiene Actualmente %d Clientes\n",RecorrerCola());
//if ((F+1)%10 != I && RecorrerCola()==0)
if (RecorrerCola()<10)
printf("\t\t\n 1- Ingresar Cliente a la Cola ");
else
printf("\t\t\n 1- La Cola en estos momentos se encuentra llena");
if (RecorrerCola()!=0){
if (Acciones<10)
printf("\t\t\n 2- Atender Cliente");
}
printf("\t\t\n 3- Cerrar Cajas y Mostrar Totales ");
printf("\t\t\n 4- Salir del Programa\n");
printf("\t\t\n Opcion :");
scanf("%d",&opcion);
}
switch (opcion){
case 1:IngresarCliente();
break;
case 2:MenuAtender();
break;
case 3:CerrarCajas();
//MostrarTotales();
break;
case 4:Salir();
break;
default:MenuPrincipal();
}
}
/*******************************************************************
*
*
Funcion para Poder atender a un cliente.
*
********************************************************************
*/
void MenuAtender(){
int opcion=0;

while (opcion==0){
LimpiarVentana();
textcolor(BLUE);
Linea("_");
printf("\n\t\t\t BANCO \n");
//Cual=CualCliente();
printf("\n\t\t
Atender Cliente Numero %d\n",Acciones);
Linea("_");
if (fin1->Saldo>0 || fin2->Saldo>0 || fin3->Saldo >0 ){
if (RecorrerCola()!=0){
printf("\t\t\n 1- Realizar un Giro");
printf("\t\t\n 2- Realizar un Deposito");
printf("\t\t\n 3- Salir\n");
printf("\t\t\n Opcion :");
scanf("%d",&opcion);
switch (opcion){
case 1:HacerGiro();
break;
case 2:HacerDeposito();
break;
case 3:MenuPrincipal();
break;
default:MenuAtender();
}
}else
MenuPrincipal();
}else {
textcolor(LIGHTRED);
printf(" Las Cajas Han quedado sin Saldo\n");
printf(" Por lo tanto se han Cerrado.\n");
textcolor(BLUE);
printf("\n Presione alguna tecla para Mostrar los Totales.");
Pausa
MostrarTotales();
}
}
}
/*******************************************************************
*
*
Funcion que permite ingresar un Cliente a la cola.
*
********************************************************************
*/

void IngresarCliente(){
if (RecorrerCola()<10){
F = (F + 1) % 10;
ColaClientes[F]=1;
NumClientes++;
if (I==-1)
I++;
}

MenuPrincipal();
}
int RecorrerCola(){
int x;
int Suma=0;
if (I!=-1){
x=I;
while( x!= F ){
Suma = Suma + ColaClientes[x];
x = (x+1) % 10;
}
if (F==x)
Suma = Suma + ColaClientes[x];
}
return (Suma);
}
/*******************************************************************
*
*
Funcion que permite Realizar un Giro.
*
********************************************************************
*/
void HacerGiro(){
LimpiarVentana();
textcolor(BLUE);
Linea("_");
printf("\n\t\t\t BANCO \n");
printf("\n\t\t
Realizar un Giro \n");
Linea("_");
if (NoGirar==1){
textcolor(LIGHTRED);
printf(" Su giro a Sobrepasado el Saldo de la Caja Seleccionada\n");
printf(" Por favor seleccione otra caja para hacer su giro. \n");
}
textcolor(BLUE);
printf("\t\t\n Solo Estan Disponibles las Cajas\n");
int opcion=0;
while (opcion==0){
if (fin1->Saldo > 0)
printf("\t\t\n 1- Caja %d Saldo = $ %ld ",Caja1->Id,fin1->Saldo);
else
printf("\t\t\n 1- Caja %d Cerrada",Caja1->Id);
if (fin2->Saldo > 0)
printf("\t\t\n 2- Caja %d Saldo = $ %ld ",Caja2->Id,fin2->Saldo);
else
printf("\t\t\n 1- Caja %d Cerrada",Caja2->Id);
if (fin3->Saldo > 0)
printf("\t\t\n 3- Caja %d Saldo = $ %ld\n",Caja3->Id,fin3->Saldo);
else
printf("\t\t\n 1- Caja %d Cerrada",Caja3->Id);

printf("\t\t\n 4- Salir\n");
printf("\t\t\n Opcion :");
scanf("%d",&opcion);
}
struct NodoCaja *auxGiro1;
struct NodoCaja *auxGiro2;
struct NodoCaja *auxGiro3;
switch (opcion){
case 1:if (fin1->Saldo > 0){
printf("\t\t\n De Cuanto Sera Su Giro : $ ");
auxGiro1=(struct NodoCaja*)malloc(sizeof(struct NodoCaja));
scanf("%ld",&auxGiro1->DinSalida);
if (auxGiro1->DinSalida > fin1->Saldo){
NoGirar=1;
HacerGiro();
} else {
NoGirar=0;
auxGiro1->sig = NULL;
auxGiro1->Id=1;
auxGiro1->DinEntrada=0;
ColaClientes[I]=0;
I++;
NumClientes--;
Acciones++;
if (fin1==NULL) {
Caja1 = auxGiro1;
fin1 = Caja1;
} else {
auxGiro1->Saldo = (fin1->Saldo) - (auxGiro1->DinSalida);
fin1->sig = auxGiro1;
fin1 = auxGiro1;
}
MostrarSaldoFinal(Caja1);
}
} else {
HacerGiro();
}
break;
case 2:if (fin2->Saldo > 0){
printf("\t\t\n De Cuanto Sera Su Giro : $ ");
auxGiro2=(struct NodoCaja*)malloc(sizeof(struct NodoCaja));
scanf("%ld",&auxGiro2->DinSalida);
if (auxGiro2->DinSalida > fin2->Saldo){
NoGirar=1;
HacerGiro();
} else {
NoGirar=0;
auxGiro2->sig = NULL;
auxGiro2->Id=2;

auxGiro2->DinEntrada=0;
ColaClientes[I]=0;
I++;
NumClientes--;
Acciones++;
if (fin2==NULL) {
Caja2 = auxGiro2;
fin2 = Caja2;
} else {
auxGiro2->Saldo = (fin2->Saldo) - (auxGiro2->DinSalida);
fin2->sig = auxGiro2;
fin2 = auxGiro2;
}
MostrarSaldoFinal(Caja2);
}
} else {
HacerGiro();
}
break;
case 3:if (fin3->Saldo > 0){
printf("\t\t\n De Cuanto Sera Su Giro : $ ");
auxGiro3=(struct NodoCaja*)malloc(sizeof(struct NodoCaja));
scanf("%ld",&auxGiro3->DinSalida);
if (auxGiro3->DinSalida > fin3->Saldo){
NoGirar=1;
HacerGiro();
} else {
NoGirar=0;
auxGiro3->sig = NULL;
auxGiro3->Id=3;
auxGiro3->DinEntrada=0;
ColaClientes[I]=0;
I++;
NumClientes--;
Acciones++;
if (fin3==NULL) {
Caja3 = auxGiro3;
fin3 = Caja3;
} else {
auxGiro3->Saldo = (fin3->Saldo) - (auxGiro3->DinSalida);
fin3->sig = auxGiro3;
fin3 = auxGiro3;
}
MostrarSaldoFinal(Caja3);
}
} else {
HacerGiro();
}

break;
case 4:MenuAtender();
break;
default:HacerGiro();
}
Pausa
}
/*******************************************************************
*
*
Funcion que permite Mostrar El Saldo final de Una Caja.
*
********************************************************************
*/
void MostrarSaldoFinal(NodoCaja *aux){
NodoCaja *x;
x=aux;
while(x->sig!=NULL){
x=x->sig;
}
printf(" La Caja %d Quedo con en Saldo de : $ %ld\n\n",x->Id,x->Saldo);
Pausa
MenuAtender();
}
void MostrarSaldo(NodoCaja *auxS){
NodoCaja *x;
x=auxS;
while(x->sig!=NULL){
x=x->sig;
}
printf("\t Los totales de la Caja %d son:\n",x->Id);
printf("\t Saldo : %ld\n",x->Saldo);
MostrarGiros(auxS);
}
/*******************************************************************
*
*
Funcion que permite Mostrar Los Giros efectuados en una Caja.
*
********************************************************************
*/
void MostrarGiros(NodoCaja *auxG){
NodoCaja *x;
x=auxG;
long SumaGiro=0;
while(x->sig!=NULL){
x = x->sig;
SumaGiro = SumaGiro + x->DinSalida;
}
printf("\t Dinero Retirado : $ %ld\n",SumaGiro);
MostrarDepositos(auxG);
}

/*******************************************************************
*
*
Funcion que permite Mostrar Los Depositos efectuados en una Caja.
*
********************************************************************
*/
void MostrarDepositos(NodoCaja *auxD){
NodoCaja *x;
x=auxD;
long SumaDeposito=0;
while(x->sig!=NULL){
x = x->sig;
SumaDeposito = SumaDeposito + x->DinEntrada;
}
printf("\t Dinero Depositado : $ %ld\n",SumaDeposito);
}
/*******************************************************************
*
*
Funcion que permite Mostrar todos los Totales.
*
********************************************************************
*/
void MostrarTotales(){
LimpiarVentana();
textcolor(BLUE);
Linea("_");
printf("\n\t\t\t BANCO \n");
textcolor(LIGHTRED);
printf("\n\t\t\t Totales (Caja 1)\n");
textcolor(BLUE);
Linea("_");
printf("\n");
MostrarSaldo(Caja1);
printf("\nPresione alguna tecla...\n\n");
Pausa
LimpiarVentana();
Linea("_");
printf("\n\t\t\t BANCO \n");
textcolor(LIGHTRED);
printf("\n\t\t\t Totales (Caja 2)\n");
textcolor(BLUE);
Linea("_");
printf("\n");
MostrarSaldo(Caja2);
printf("\nPresione alguna tecla...\n\n");
Pausa
LimpiarVentana();
Linea("_");
printf("\n\t\t\t BANCO \n");
textcolor(LIGHTRED);
printf("\n\t\t\t Totales (Caja 3)\n");
textcolor(BLUE);
Linea("_");
printf("\n");

MostrarSaldo(Caja3);
printf("\nPresione alguna tecla...\n\n");
Pausa
Salir();
}

/*******************************************************************
*
*
Funcion que permite Realizar un Deposito.
*
********************************************************************
*/
void HacerDeposito(){
LimpiarVentana();
textcolor(BLUE);
Linea("_");
printf("\n\t\t\t BANCO \n");
printf("\n\t\t
Realizar un Deposito \n");
Linea("_");
int opcion=0;
while (opcion==0){
if (fin1->Saldo > 0)
printf("\t\t\n 1- Caja %d Saldo = $ %ld ",Caja1->Id,fin1->Saldo);
if (fin2->Saldo > 0)
printf("\t\t\n 2- Caja %d Saldo = $ %ld ",Caja2->Id,fin2->Saldo);
if (fin3->Saldo > 0)
printf("\t\t\n 3- Caja %d Saldo = $ %ld \n",Caja3->Id,fin3->Saldo);
printf("\t\t\n 4- Salir\n");
printf("\t\t\n Opcion :");
scanf("%d",&opcion);
}
struct NodoCaja *auxDep1;
struct NodoCaja *auxDep2;
struct NodoCaja *auxDep3;
switch (opcion){
case 1:if (fin1->Saldo != 0){
printf("\t\t\n De Cuanto Sera Su Deposito : $ ");
auxDep1=(struct NodoCaja*)malloc(sizeof(struct NodoCaja));
scanf("%ld",&auxDep1->DinEntrada);
auxDep1->sig = NULL;
auxDep1->Id=1;
auxDep1->DinSalida=0;
ColaClientes[I]=0;
I++;
NumClientes--;
Acciones++;
if (fin1==NULL) {
Caja1 = auxDep1;
fin1 = Caja1;

} else {
auxDep1->Saldo = (fin1->Saldo) + (auxDep1->DinEntrada);
fin1->sig = auxDep1;
fin1 = auxDep1;
}
MostrarSaldoFinal(Caja1);
} else {
HacerDeposito();
}
break;
case 2:if (fin2->Saldo != 0){
printf("\t\t\n De Cuanto Sera Su Deposito : $ ");
auxDep2=(struct NodoCaja*)malloc(sizeof(struct NodoCaja));
scanf("%ld",&auxDep2->DinEntrada);
auxDep2->sig = NULL;
auxDep2->Id=2;
auxDep2->DinSalida=0;
ColaClientes[I]=0;
I++;
NumClientes--;
Acciones++;
if (fin2==NULL) {
Caja2 = auxDep2;
fin2 = Caja2;
} else {
auxDep2->Saldo = (fin2->Saldo) + (auxDep2->DinEntrada);
fin2->sig = auxDep2;
fin2 = auxDep2;
}
MostrarSaldoFinal(Caja2);
} else {
HacerDeposito();
}
break;
case 3:if (fin3->Saldo != 0){
printf("\t\t\n De Cuanto Sera Su Deposito : $ ");
auxDep3=(struct NodoCaja*)malloc(sizeof(struct NodoCaja));
scanf("%ld",&auxDep3->DinEntrada);
auxDep3->sig = NULL;
auxDep3->Id=3;
auxDep3->DinSalida=0;
ColaClientes[I]=0;
I++;
NumClientes--;
Acciones++;
if (fin3==NULL) {
Caja3 = auxDep3;
fin3 = Caja3;

} else {
auxDep3->Saldo = (fin3->Saldo) + (auxDep3->DinEntrada);
fin3->sig = auxDep3;
fin3 = auxDep3;
}
MostrarSaldoFinal(Caja3);
} else {
HacerDeposito();
}
break;
case 4:MenuAtender();
break;
default:HacerDeposito();
}
Pausa
}
/*******************************************************************
*
*
Funcion que permite Salir del programa.
*
********************************************************************
*/
void Salir(){
LimpiarVentana();
printf("\n\n Gracias Por Usar Este Programa.\n\n");
printf(" Programado Por:\n\n");
printf("\t - Victor Utreras\n\t - Gonzalo Castillo\n\t - Curso: 3101\n\t - Ano: 2003.\n");
printf("\n\n Presione alguna tecla...");
Pausa
exit(1);
}
/*******************************************************************
*
*
Funcion principal MAIN().
*
********************************************************************
*/
void CrearVentana(unsigned char _ColorFondo=WHITE,
unsigned char _ColorTexto=BLACK,
const char *Titulo_Ventana = "")
{
titulo(Titulo_Ventana);
textbackground(_ColorFondo); //define el fondo blanco (15 WHITE)
textcolor(_ColorTexto); //define el color de texto negro (0 o BLACK)
clrscr();
}
int main(int argc, char *argv[]){
CrearVentana(WHITE,BLUE," Trabajo de Estructura de Datos GI-3101");
IniciarCaja();
return 0;
} //END_MAIN