Atenção: Precisando de assessoria nos seus PROJETO entre em contato com a SGP
Descrição do Programa:
Em um setor jurídico de uma rede de supermercados, para simplificar o
seu serviço é resolver processos que serão passados pelo seu chefe para você.
Estes processos tratam de cheques de clientes que voltaram do banco,
isto é, tratam de clientes que deram cheque sem fundo para pagar alguma compra
em um dos supermercados da grande rede.
Seu chefe ao te passar um serviço te dá às informações referentes ao
processo.
No caso as informações
do Cliente: nome, endereço, identidade, e telefone do
cliente; valor e data do cheque; e o nome do supermercado que o cliente
passou o cheque. Além disso, cada processo vai possuir um identificador único.
Os processos são
organizados em uma pilha.
Você executa sempre o serviço que está no topo da pilha.
Só que esta pilha não é uma pilha comum, ela tem prioridade relacionada ao valor do cheque.
Os processos que estiver relacionado
ao valor de cheque mais alto fica no topo da pilha, e o que estiver
relacionado ao valor mais baixo fica na base da pilha.
Caso algum dos supermercados esteja precisando muito de dinheiro,
seu chefe entrará em contato com você e te avisará este fato.
Neste caso você terá que realocar a pilha colocando todos os processos
que estão relacionados ao supermercado com problema no topo, e os outros
continuará na ordem anterior.
Além disso, caso o seu chefe considere algum processo muito importante,
ele poderá te pedir para resolvê-lo, mas estar tentando resolvê-lo também sem
você saber.
Neste caso se ele resolver o caso antes de você, ele entrará em contato
com você e te avisará para ignorar tal processo.
Você então terá que retirar tal processo da pilha, estando ele onde
estiver. Você deve ser capaz de responder quais identificadores dos processos,
quais os nomes dos clientes, e quais os valores dos cheques que estão na pilha;
e ainda, qual identificador do processo, qual nome do cliente, qual valor do
cheque do processo do topo.
O programa vai simular a situação descrita acima. O usuário do programa é o seu chefe.
O programa conterá funções básicas como de empilhar processos de acordo
com a prioridade (valor do cheque),
desempilhar processos, atribuir as características (ID, nome do cliente,
quantia, etc) a cada processo.
Mudar a prioridade de um processo (e com isso mudar a posição dele na
pilha), listar as características de todos os processos que estão na pilha,
listar as características de um determinado processo com ID igual a X
(qualquer), listar as características do processo que está no topo da pilha,
listar as características do processo que está na base da pilha, remover um
processo com ID igual a X (qualquer).
Basicamente o programa vai simular como controlar uma pilha. O conceito
de pilha é onde se coloca um em cima de outra por exemplo uma pilha de livros,
podemos colocar vários livros em cima do outro mas quando eu quero tirar um
livro que esteja lá em baixo eu vou ter que ir tirando um por um de cima é
criando uma outra pilha. Na verdade eu posso tirar o livro de baixo mas a pilha
vai cair. Isso é um conceito básico de pilha.
O Programa irá simular o conceito de pilha de processo jurídico de um
supermercado, onde os clientes deram cheque sem fundo e agora terá que resolver
esses problemas. Terá o cadastro do cliente com os seus dados e os processos
terá prioridades para ser resolvidos também referente ao valor do cheque. Os processos que estiver relacionado ao
valor de cheque mais alto fica no topo da pilha, e o que estiver relacionado ao
valor mais baixo fica na base da pilha. E caso o supermercado estiver
precisando muito de dinheiro o seu chefe vai entrar em contato e você terá que
resolver esse processo primeiro. Dai você vai realocar a pilha original numa
pilha temporária até achar o processo e resolve-lo e depois realocar a pilha original
em sua prioridade.
#include <cstdlib>
#include <iostream>
#include <stdlib.h>
#include <locale.h>
#include <string.h>
using namespace std;
#define T 50/*NUMERO MAXIMO DE CADASTROS*/
/*ESTRUTURA DO CADASTRO PARA GUARDAR DADOS DO CLIENTE*/
typedef struct {
char nome[30], endereco[40], nomeMercado[20], dataCheque[12];
int id, identidade, telefoneCliente;
float valor;
}CLIENTE;/*FINAL DA ESTRUTURA DO CADASTRO*/
/*ESTRUTURA DA PILHA DE CADASTRO*/
typedef struct {
int topo;
CLIENTE cli[T];
}PILHA;/*FIM DA ESTRUTURA DA PILHA DE CADASTRO*/
void iniciarPilha(PILHA *p);/*INICIALIZA A PILHA*/
int menu();/*MOSTRA MENU*/
int menuChefe();/*MENU DO CHEFE*/
int menuRelatorio();/*MENU DO RELATORIO*/
int overflow(PILHA *p);/*VERIFICA SE A PILHA ESTÁ CHEIA*/
int underflow(PILHA *p);/*VERIFICA SE A PILHA ESTÁ VAZIA*/
void push(PILHA *p, CLIENTE *cl);/*INSERE NA PILHA*/
void pushPrioridade(PILHA *p, PILHA *temp ,CLIENTE *cli);//INSERE QUANDO TEM PRIORIDADES
void OrganizarPIlhaPrioridadeValor(PILHA *p, PILHA *temp);/*ORGANIZA A PILHA PELA PRIORIDADE DO VALOR DO CHEQUE*/
void OrganizarPIlhaPrioridadeMercado(PILHA *p, PILHA *temp);/*ORGANIZA PRIORIDADE QUE O CHEFE DETERMINA PARA O MERCADO*/
void OrganizarDecrescente(PILHA *p, PILHA *temp);/*PROCESSO DE ORGANIZAR EM ORDEM DECRESCENTE PELO MERCADO // PREPARA PARA OS RETIRADOS RETORNAREM PARA A PILHA ORIGINAL */
void removerCasoResolvido(PILHA *p, int processo);/*REMOVE CASO RESOLVIDO PELO CHEFE*/
void imprimirPilhaSimplificada(PILHA *p);/*IMPRIME UM SÓ ELEMENTO*/
void imprimirPilhaEscolhido(PILHA *p, int id);/*IMPRIME POR BUSCA ESCOLHIDA // POR ID, POR BASE, POR TOPO*/
CLIENTE pop(PILHA *p);/*REMOVE UM SÓ ELEMNTO*/
void imprimirPilha(PILHA *p);/*IMPRIME A PILHA INTEIRA COM TODOS OS ELEMENTOS*/
void removerEscolhido(PILHA *p, PILHA *pt, int esc);/*REMOVE UM ELEMENTO DA PILHA ESCOLHIDO*/
//remove um elemento da pilha escolhido, serve para fazer no caso, quando se escolhe alocar os nome do
//mercado e no caso resolvido pelo chefe
void relatorio(PILHA *p, int op);/*RELATORIO*/
int idCliente = 0;/*CADASTRO DOS ID DOS CLIENTES ONDE NUNCA IRÁ REPTIR*/
int contPrioridade = 0;//FAZ CONTAGEM DAS PRIORIDADES
//============================INICIO DAS FUNÇÕES
//=============FUNÇÃO QUE IRÁ INCIALIZAR A PILHA
void iniciarPilha(PILHA *p){
p->topo = -1;//inicia a pilha em -1, para quando começar, a inserir, o elemento seja o 0, igual ao no vetor..
}
//=============FUNÇÃO QUE IRÁ CHAMAR O MENU PRINCIPAL DE OPÇÕES
int menu(){
int opc;//VARIAVEL PARA RECEBER A OPÇÃO
system("cls");
cout<<"\n***********************MENU DE CONTROLE DA PILHA*****************************\n"<< endl;
cout<<"\t1-Novo cadastro\n"<< endl
<< "\t2-Imprimir pilha\n"<< endl
<<"\t3-Aviso do chefe\n"<< endl
<<"\t4-Relatorio \n"<< endl
<<"\t0-Sair\n"<< endl;
cin>>opc;//VAI QUARDAR A OPÇÃO SELECIONADO PELO USUÁRIO
getchar();
return opc;//RETORNA A OPÇÃO
}
//==================FUNÇÃO PARA RETORNAR O MENU DO CHEFE
int menuChefe(){//mesma coisa de cima
int opc;
system("cls");
cout<<"\n***********************AVISO DO CHEFE*****************************\n"<< endl;
cout<<"1-Supermercados precisando muito de dinheiro"<< endl
<<"2-Caso resolvido"<< endl
<< "0-Sair\n"<< endl;
cin>>opc;
getchar();
return opc;
}
Atenção: Precisando de ajuda entre em contato com a SGP e solicite uma assessoria com a melhor equipe do mercado no desenvolvimento de trabalhos acadêmicos
E-mail: ajudastrabalhosprogramacao@gmail.com
Facebook: fb.me/ajudaemTrabalhosdeprogramacao
