Nombres: Gonzalo CastilloVíctor Utreras

Curso : 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 versión es para ser compilada en Visual-C++. La única diferencia radica en el uso de la librería para las funciones de pantalla.Conio.h para Dev-C++ y VGLib.h para Visual-C++,Ya que las funciones entre una versión y otra son levemente diferentes.

Constantes utilizadas

Para texcolor, textbackground, ColorTexto, CrearVentana,etc.

BLACK 0 //NEGROBLUE 1 //AZUL MARINOLIGHTRED 12 //ROJO CLAROWHITE 15 //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 guardarTodas las transacciones ya sea giros, depósitos 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 transacción se guarda el valor de esa transacción en las variables miembro de la estructura, si es giro se guarda en DinSalida y si es deposito se guarda en DinEntrada, además el Saldo de cada caja se actualiza por cada transacción, 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 transacción, además se guarda el ID de la caja para saber que caja es. Y asi es sucesivamente por cada transacción 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 Identificación de la Caja.DinSalida : Guarda el Giro (Solamente si es realizado)DinEntrada : Guarda el Deposito (Solamente si es realizado)*Sig : Guarda la dirección 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 función MostrarTotales() al final del programa.

void Salir(): Termina el programa y muestra los créditos.

inline void LimpiarVentana(): Borra la pantalla.

inline void Linea(const char *caracter): Dibuja una línea 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