pratica 14

//########################################################################################
//                  pratica_14.c
//########################################################################################

/*Quesito 02: Faça um programa para simular as filas de um banco (considere 5 filas de atendimento). O laço do programa principal deve conter a seguinte seqüência de comandos:
- Sortear (random) uma das filas e adicionar um cliente novo que chegou ao banco;
- Sortear (random) uma das filas para ser atendido um cliente. Retirar um cliente da fila que foi sorteada para ser atendida;
- Mostrar na tela o estado das filas, ou seja, a quantidade de clientes que tem em cada uma das filas;
- Repetir este procedimento 20 vezes.
OBS. Cada cliente deverá ser identificado por um número inteiro positivo seqüencial associado ao mesmo quando chegar ao banco.*/

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include "fila.h"
#include "fila.c"


int main (void){

    srand(time(NULL));
    Fila* f[5];
    int id=1 , escolha,aux;

    f[0] = Fila_cria();
    f[1] = Fila_cria();
    f[2] = Fila_cria();
    f[3] = Fila_cria();
    f[4] = Fila_cria();

    for (;;){

    system("clear");

    printf("____________________Fila do Banco___________________\n\n");
    printf("\nDigite a opcao desejada:\n\n");
    printf("[1] Novo Cliente\n");
    printf("[2] Atender cliente\n");
    printf("[3] Mostrar FILAS\n");
    printf("[9] Sair\n\n");
    printf("Opcao escolhida: ");
    scanf("%d", &escolha);

    switch(escolha){

        case 1:
        if(id<=20){
        aux=rand()%5+0;
        novo_cliente(f[aux],id,aux);
        id++;}
        else {
        system("clear");
        printf("\nLimite de pessoas no banco excedido.");
}
    printf("\n\nAperte ENTER para continuar.");
        __fpurge(stdin);
        getchar();
        system("clear");
        break;

        case 2:
        aux=rand()%5+0;
        atender_cliente(f[aux],aux);
        printf("\n\nAperte ENTER para continuar.");
        __fpurge(stdin);
        getchar();
        system("clear");
        break;

        case 3:
        system("clear");
        printf("\n\nFila 01 = ");
        mostrar_filas(f[0]);
        printf("\n\nFila 02 = ");
        mostrar_filas(f[1]);
        printf("\n\nFila 03 = ");
        mostrar_filas(f[2]);
        printf("\n\nFila 04 = ");
        mostrar_filas(f[3]);
        printf("\n\nFila 05 = ");
        mostrar_filas(f[4]);
        printf("\n\nAperte ENTER para continuar.");
        __fpurge(stdin);
        getchar();
        system("clear");
        break;

        case 9:
        Fila_libera(f[0]);
        Fila_libera(f[1]);
        Fila_libera(f[2]);
        Fila_libera(f[3]);
        Fila_libera(f[4]);
        system("clear");
                exit(1);

        default :
            system("clear");
            printf("Digite uma opcao valida.");
            printf("\n\nAperte ENTER para continuar.");
        __fpurge(stdin);
        getchar();
        system("clear");
            break;
        }
    }


}

void novo_cliente( Fila *f, int id, int aux ){
    system("clear");
    insere(f,id);
    printf("O cliente [%d] foi adicionado na fila [%d]", id , aux+1);
}

void atender_cliente( Fila *f , int aux){
    int saiu;
    system("clear");
    saiu=retira(f);
    system("clear");
    if (saiu==NULL){printf("A fila [%d] esta vazia.", aux+1);}
    else{
    printf("O cliente [%d] foi da fila [%d] foi atendido", saiu , aux+1);}
    }

void mostrar_filas( Fila *f ){

    Fila_imprime(f);

}


//########################################################################################
//                  fila.c
//########################################################################################

#include <stdio.h>
#include <stdlib.h>
#include "fila.h"

/*****************************************************************************/
Fila* Fila_cria (void) {
    Fila* f = (Fila*) malloc(sizeof(Fila));
    f->ini = f->fim = NULL;
    return f;
}
/*****************************************************************************/
Fila_No* Fila_ins_fim (Fila_No* fim, float v) {
    Fila_No* p = (Fila_No*) malloc(sizeof(Fila_No));
    p->info = v;
    p->prox = NULL;
    if (fim != NULL) /* verifica se lista não estava vazia */
        fim->prox = p;
    return p;
}
/*****************************************************************************/
Fila_No* Fila_ret_ini (Fila_No* ini) {
    Fila_No* p = ini->prox;
    free(ini);
    return p;
}
/*****************************************************************************/
void insere (Fila* f, float v) {
    f->fim = Fila_ins_fim(f->fim,v);
    if (f->ini==NULL) /* fila antes vazia? */
    f->ini = f->fim;
}
/*****************************************************************************/
float retira (Fila* f) {
    float v;
    if (Fila_vazia(f)) {
        printf("Fila vazia.\n");
        return 0;
    }
    v = f->ini->info;
    f->ini = Fila_ret_ini(f->ini);
    if (f->ini == NULL) /* fila ficou vazia? */
        f->fim = NULL;
    return v;
}
/*****************************************************************************/
int Fila_vazia (Fila* f) {
    return (f->ini==NULL);
}
/*****************************************************************************/
void Fila_libera (Fila* f) {
    Fila_No* q = f->ini;

    while (q!=NULL) {
        Fila_No* t = q->prox;
        free(q);
        q = t;
    }
    free(f);
}
/*****************************************************************************/
/* imprime: versão com lista */
void Fila_imprime (Fila* f) {
    Fila_No* q;
    for (q=f->ini; q!=NULL; q=q->prox)
        printf(" [%.1f] ",q->info);
}


//########################################################################################
//                  fila.h
//########################################################################################


#ifndef FILA_H
#define FILA_H

typedef struct {
    float info;
    struct no* prox;
} Fila_No;

typedef struct {
    Fila_No* ini;
    Fila_No* fim;
} Fila;
/* aloca a estrutura da fila e inicializa a lista como sendo vazia. */
Fila* Fila_cria (void);
/* função auxiliar: insere no fim */
Fila_No* Fila_ins_fim (Fila_No* fim, float v);
/* função auxiliar: retira do início */
Fila_No* Fila_ret_ini (Fila_No* ini);
/* funções para manipulação de filas */
void insere (Fila* f, float v);
float retira (Fila* f);
int Fila_vazia (Fila* f);
void Fila_libera (Fila* f);
/* imprime: versão com lista */
void Fila_imprime (Fila* f);
#endif /* FILA_H */