Atividade Final - Unidade 3 - Técnicas de Programação

Prévia do material em texto

Em algumas situações, para a implementação de um sistema computacional, não se conhece, previamente, qual o tamanho da massa de dados que será efetivamente manipulada. Em tais casos, pode ser usado o recurso de alocação dinâmica de memória. Com tal recurso, uma região de memória poderá ser alocada, sob demanda de modo a tornar o programa mais flexível em relação à quantidade de itens a serem manipulados. Essa flexibilidade torna o programa escalável.
O objetivo desta questão é exercitar a manipulação de ponteiros em um cenário onde se exige a alocação dinâmica de memória através da implementação de um programa computacional.
Antes de falarmos das funcionalidades do programa a ser implementado, convém mencionar que, em algumas situações o espaço previamente alocado deve ser redimensionado devido, à por exemplo, um aumento ou diminuição inesperada na quantidade de itens manipulados. Para realizar o redimensionamento, pode-se, na linguagem C, utilizar a função “realloc()”. Essa função segue a seguinte sintaxe:
void *realloc (void *ptr_original, size_t);
A função “realloc()” retorna a posição do bloco realocado com a nova dimensão. No trecho de código acima, o parâmetro “ptr_original” representa o bloco previamente alocado com a função “malloc()” ou “calloc()”. Detalhes destas funções, inclusive a “realloc()” poderão ser obtidas acessando-se (GARCIA, 2016) através do link: <https://www.embarcados.com.br/ponteiro-em-c-alocacao-dinamica/>.
Para a realização desta atividade, suponha a necessidade de cadastrar clientes de uma loja. Por ser uma loja nova e com produtos inovadores, pouco se sabe do mercado a ser atingido, sendo assim, não se sabe a quantidade de clientes poderão ser cadastrados. Estima-se, inicialmente, em 10 clientes. Cada cliente terá os seguintes
campos:
- nome (suponha um nome com, no máximo, 30 caracteres)
- ano de nascimento
- montante de gastos realizados no mês (quanto o clinte pagou em suas compras dentro do mês corrente)
Para tanto, o sistema deverá oferecer as seguintes funcionalidades:
- incluir um novo cliente
- remover cliente - atualizar o montante de compras do cliente realizadas no mês corrente
- zerar todos os montantes de compras por ocasião da virada de mês
- listar o cliente melhor comprador
- exibir um montante de compras de um cliente específico.
O programa deverá, ainda, prever a situação que a quantidade de clientes a ser cadastrados supere a previsão inicial. Neste caso, quando o espaço de memória destinado a receber dados dos clientes estiver cheia, deve-se ampliar esse espaço – sempre em blocos de 10.
Poste o código, implementado em C, em seu portfólio.
Bons Estudos!
Referência DEITEL, P. J.; DEITEL, H. C: Como Programar. 6. Ed. São Paulo: Pearson Prentice Hall, 2011. [Recurso eletrônico, Biblioteca Virtual Universitária]
GARCIA, F. D. Ponteiro em C: Alocação Dinâmica de Memória. Publicado em 08/01/2016. Disponível em <https://www.embarcados.com.br/ponteiro-em-c-alocacao-dinamica/>. Acesso em 05/07/2019.
		Resposta Selecionada:
	#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <locale.h>
#include <conio.h>
#define TAMANHO 10 // Determinando tamanho 10
/*Para a realização desta atividade, suponha a necessidade de cadastrar clientes de uma loja.
Por ser uma loja nova e com produtos inovadores, pouco se sabe do mercado a ser atingido, sendo assim,não se sabe a quantidade de clientes poderão ser cadastrados.
Estima-se, inicialmente, em 10 clientes. Cada cliente terá os seguintescampos:
- nome (suponha um nome com, no máximo, 30 caracteres)
- ano de nascimento- montante de gastos realizados no mês (quanto o clinte pagou em suas compras dentro do mês corrente)
Para tanto, o sistema deverá oferecer as seguintes funcionalidades:
- incluir um novo cliente
- remover cliente
- atualizar o montante de compras do cliente realizadas no mês corrente
- zerar todos os montantes de compras por ocasião da virada de mês
- listar o cliente melhor comprador
- exibir um montante de compras de um cliente específico.
O programa deverá, ainda, prever a situação que a quantidade de clientes a ser cadastrados supere a previsão inicial.
Neste caso, quando o espaço de memória destinado a receber dados dos clientes estiver cheia, deve-se ampliar esse espaço – sempre em blocos de 10.*/
void cabecalho() // Cabeçalho do Programa
{   
printf("***********************************************************************************************\n");   
printf("\t\t\tATIVIDADE 3 - DICIPLINA TÉCNICAS DE PROGRAMAÇÃO\n");   
printf("***********************************************************************************************\n\n");
}
typedef struct { // tipo de dados e definição da struct   
char nome[30];   
int ano;   
float gastos;}
Cliente; //definido a variavél da struct cadastro
void cadastarCliente();
void gastoTotaisCliente();
void printCliente(Cliente *cliente);
void viradaMes();
void melhorComprador();
void inicializacao();
void realocarCliente();
void bubbleSort();
void pressioneParaContinuar();
void listaCliente();
void removerCliente();
void atualizarGastosCliente();
Cliente * pCliente;int *pClienteTamanho;
int main(){ 
setlocale(LC_ALL, "Portuguese"); // Utilizar acentuação do idioma português
 inicializacao();
    int clienteTamanho = -1;   
pClienteTamanho = &clienteTamanho;
    int op = 99;   
while(op > 0) {           
system("cls");           
cabecalho();           
printf(" Selecione uma das opções: \n\n");           
printf("(1) Cadastrar um Cliente \n");           
printf("(2) Gastos Totais por Cliente\n");           
printf("(3) Melhor Comprador\n");           
printf("(4) Remover Cliente\n");           
printf("(5) Virada de Mês\n");           
printf("(6) Listar Todos Clientes\n");           
printf("(7) Atualizar Gastos Cliente\n");           
printf("(0) Sair o Sistema\n\n");           
printf("Informe a opção desejada: ");           
scanf("%i", &op);
        system("cls");       
switch(op) {           
case 1:               
cadastarCliente();               
break;           
case 2:               
gastoTotaisCliente();               
break;           
case 3:               
melhorComprador();               
break;           
case 4:               
removerCliente();               
break;           
case 5:               
viradaMes();               
break;           
case 6:               
listaCliente();               
break;           
case 7:               
atualizarGastosCliente ();               
break;        }
       
if(op<0 || op>8)        {           
cabecalho();           
printf("\n\n");           
printf("\n\t\t ******************** OPCÃO INCORRETA! DIGITE NOVAMENTE******************** \n\n");           
printf("\n\n");           
system("pause");       
}       
if (op ==0)        {               
cabecalho();               
printf("\n***********************************************************************************************");               
printf("\n\t\t\t\t\tPROGRAMA ENCERRADO!\n");               
printf("***********************************************************************************************\n\n");               
printf("\n\t\t\t\t\t\BY: BEATRIZ LEANDRA\n");               
printf("\n***********************************************************************************************\n\n");               
return 0;               
break;       
}   
}
 free(pCliente); pCliente = NULL;
    return 0;}
void cadastarCliente() {   
system("cls");   
cabecalho();   
printf("Gastos totais por cliente: \n\n");
    *pClienteTamanho = *pClienteTamanho + 1;
    Cliente *cliente = &pCliente[*pClienteTamanho];   
strcpy(cliente->nome, "");   
cliente->ano = 0;   
cliente->gastos = -1;
    system("cls");   
cabecalho();
    while(strlen(cliente->nome) < 2) {       
printf("Digite o nome do cliente: ");       
scanf(" %[^\n]s", &cliente->nome);
        if(strlen(cliente->nome) < 2) {           
printf("Entrada inválida!\n");       
}   
}
    while(cliente->ano < 1){       
printf("\nDigite o ano de nascimento: ",cliente->nome);       
scanf("%i", &cliente->ano);
        if(cliente->ano < 1) {           
printf("Entrada inválida!\n");       
}   
}
    while(cliente->gastos < 0) {       
printf("\nInforme o gasto mensal (Usar vírgula para decimais): ",
cliente->nome, cliente->ano);       
scanf("%f", &cliente->gastos);
        if(cliente->gastos < 0) {           
printf("Entrada inválida!\n");       
}   
}
    printf("\n\nCadastro realizado com sucesso!\n\nCliente: %s , nascido em %i gastou R$ %.2f esse mês!", cliente->nome, cliente->ano, cliente->gastos);
    if(*pClienteTamanho % TAMANHO == 0) {       
realocarCliente();     
}
    bubbleSort();
    pressioneParaContinuar();
}
void gastoTotaisCliente() {
    system("cls");   
cabecalho();   
printf("Gastos totais por cliente: \n\n");
    char nome[30] = "";   
while(strlen(nome) < 2) {       
printf("Digite o nome do cliente: ");       
scanf(" %[^\n]s", &nome);
        if(strlen(nome) < 2) {           
printf("Entrada inválida!\n");       
}   
}
    int i;   
for (i = 0; i <= *pClienteTamanho; i++) {       
Cliente *cliente = &pCliente[i];
        if(strcmp(cliente->nome, nome) == 0) {           
printCliente(cliente);       
}               
if(strcmp(cliente->nome, nome) == 1) {
                printf("\nNão possui este cliente cadastrado no sistema!\n");               
break;
                }   
}
    pressioneParaContinuar();
}
void removerCliente() {
    system("cls");   
cabecalho();   
printf("Remoção de cliente por nome: \n\n");
    char nome[30] = "";   
while(strlen(nome) < 2) {       
printf("Digite o nome do cliente: ");       
scanf(" %[^\n]s", &nome);
        if(strlen(nome) < 2) {           
printf("Entrada Inválida!\n");       
}   
}
    int i, removed = 0;
    for (i = 0; i <= *pClienteTamanho; i++) {       
Cliente *cliente = &pCliente[i];
        if(strcmp(cliente->nome, nome) == 0) {           
strcpy(cliente->nome, "");           
cliente->ano = 0;           
cliente->gastos = -1;
            ++removed;       
}   
}
    bubbleSort();
    *pClienteTamanho = *pClienteTamanho - removed;
    listaCliente();
}
void melhorComprador() {
    system("cls");   
cabecalho();
    Cliente *cliente = &pCliente[0];   
printf("Comprador com maior gasto: \n\n");   
printCliente(cliente);
    pressioneParaContinuar();}
void viradaMes() {
    system("cls");   
cabecalho();   
printf("Virada de mês: \n\n");
    int i;   
for (i = 0; i <= *pClienteTamanho; i++) {       
Cliente *cliente = &pCliente[i];       
cliente->gastos = 0;   
}
    printf("\nTodos os gastos de clientes zerados!\n\n");
    pressioneParaContinuar();
}
void listaCliente() {
    system("cls");   
cabecalho();   
printf("Lista de clientes cadastrados: \n\n");
    int i;   
for (i = 0; i <= *pClienteTamanho; i++) {       
Cliente *cliente = &pCliente[i];
        printCliente(cliente);   
}
    pressioneParaContinuar();
}
void atualizarGastosCliente() {   
printf("Atualizar gastos totais por cliente\n\n");   
char nome[30] = "";   
while(strlen(nome) < 2) {       
printf("Digite o nome: ");       
scanf(" %[^\n]s", &nome);
        if(strlen(nome) < 2) {           
printf("Entrada inválida!\n");       
}   
}
    int i,aux1=0;   
for (i = 0; i <= *pClienteTamanho; i++) {       
Cliente *cliente = &pCliente[i];
        if(strcmp(cliente->nome, nome) == 0) {           
printCliente(cliente);
                printf("\nQual o novo valor gasto? (Usar vírgula para decimais): ");               
scanf("%f", &cliente->gastos);
                if(cliente->gastos < 0) {                   
printf("Entrada inválida!\n");               
}       
}
                if(strcmp(cliente->nome, nome) == 1) {
                printf("\nNão possui este cliente cadastrado no sistema!\n");               
break;
                }   
}
    pressioneParaContinuar();}
void printCliente(Cliente * cliente) {
    printf("Cliente: %s, nascido em %i  gastou R$ %.2f este mes!\n", cliente->nome, cliente->ano, cliente->gastos);
}
void pressioneParaContinuar() {   
printf("\n\nPressione qualquer tecla para continuar...");   
getch();}
void inicializacao() {   
pCliente = (Cliente *) malloc(TAMANHO * sizeof(Cliente));
    if (pCliente == NULL)    {       
printf("Memória insuficiente! Não é possível continuar.");       
printf("\n\nPressione qualquer tecla para finalizar...");       
getch();       
exit(1);   
}
}
void realocarCliente() {   
pCliente = (Cliente *) realloc(pCliente, (TAMANHO+10) * sizeof(Cliente));
    if (pCliente == NULL)    {       
printf("Memória insuficiente! Não é possível continuar.");       
printf("\n\nPressione qualquer tecla para finalizar...");       
getch();       
exit(1);   
}
}
void bubbleSort(){    //técnica para ordenar os valores de forma crescente
int i, contador;   
Cliente aux;
    for (contador = -1; contador < *pClienteTamanho; contador++) {       
for (i = 0; i <= *pClienteTamanho - 1; i++) {           
Cliente *cliente = &pCliente[i];           
Cliente *cliente2 = &pCliente[i + 1];           
if (cliente->gastos < cliente2->gastos) {               
aux = *cliente2;               
*cliente2 = *cliente;               
*cliente = aux;           
}       
}   
}
}