Lista 11 - exemplo 4

/* Cadastro persistente de dados e uso de TAD.

   Transfere dados da memória principal (vetor de ponteiros para estruturas)
   para a memória secundária (arquivo texto) e vice-versa.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_TAM_NOME_ARQUIVO 30
#define MAX_QTDE_NOMES 1000
#define MAX_NOME 31
#define MAX_TELEFONE 9
#define ARQUIVO_DEFAULT "dados.txt"

typedef struct {
   char  nome[MAX_NOME];
   char  tel[MAX_TELEFONE];
   int   dia, mes, ano;
   float valor;
} Registro;

typedef struct {
   int qtde;
   Registro *vetor[MAX_QTDE_NOMES];  // os elementos do vetor são ponteiros
} Lista;

// protótipos:
void inicia(Lista *lista);
int menu(void);
void pausa(void);
int carrega(char *nomeArquivo, Lista *lista);
void inclui(Lista *lista);
int salva(char *nomeArquivo, Lista *lista);
void exibeLista(Lista *lista);
void exibeRegistro(Registro *reg);

/*-----------------------------------------------------------------------*/
int main(int argc, char *argv[]) {
/*
Objetivo  : função principal - apresenta o menu de opções.
Argumentos: argc - número de argumentos: 2 (nome do prog e nome do arquivo)
            argv - nome do arquivo
Retorno   : 0 se execução com sucesso.
            1 se erro.
*/
   Lista lista; // cria uma lista: vetor de ponteiros para a estrutura Registro, e a qtde de elementos
   inicia(&lista);  // zera a qtde de registros da lista
   char nomeArquivo[MAX_TAM_NOME_ARQUIVO];  /* contem o nome do arquivo em disco */

   // verifica qtde de argumentos da linha de comandos
   // se maior que 2 então acusa erro e indica o uso correto
   if(argc > 2) {
      printf("Erro na chamada!\nCorreto: %s <nome_do_arquivo>\n"
             "Obs.: considera \"%s\" na falta de nome",
             argv[0], ARQUIVO_DEFAULT);
      return 1;  // o código "1" representa saída com erro
   }
   // se o nome do arquivo não for passado, considera o nome default (ARQUIVO_DEFAULT)
   else if(argc == 1)
      strcpy(nomeArquivo, ARQUIVO_DEFAULT);
   else // se argc==2 então considera o nome do arquivo passado na linha de comandos
      strcpy(nomeArquivo, argv[1]);

   // carrega os dados do arquivo para a memória principal: lista (vetor de ponteiros para estrutura)
   if(carrega(nomeArquivo, &lista) == 0)
      return 1;

   // exibe o menu e classifica a opção selecionada
   int opcao;
   do {
      opcao = menu();
      switch( opcao )
      {
         case 1 : inclui(&lista);             break;
         case 2 : exibeLista(&lista);         break;
         case 3 : salva(nomeArquivo, &lista); break;
      }
   }while(opcao != 3 && opcao != 4);
   printf("\nFim!\n");

   return 0;
}

/*----------------------------------------------------------------------*/
void inicia(Lista *lista) {
/*
Objetivo  : inicializar a lista, ajustando a qtde para zero
Argumentos: lista - ponteiro para estrutura do tipo Lista que contem os registros e a qtde.
Retorno   : nenhum.
*/
    lista->qtde = 0;
}

/*----------------------------------------------------------------------*/
int menu(void) {
/*
Objetivo  : apresentar o menu e retornar o numero da opcao escolhida.
Argumentos: nenhum.
Retorno   : numero da opcao escolhida.
*/
   printf("\n------------------------------------------");
   printf("\nMENU DE OPCOES");
   printf("\nInclui novas informacoes...............[1]");
   printf("\nExibe os dados no video................[2]");
   printf("\nSai e salva alteracoes.................[3]");
   printf("\nSai sem salvar alteracoes..............[4]");
   printf("\n------------------------------------------");
   printf("\nQual a opcao? ");
   int opcao;
   do {
      scanf("%d", &opcao);
   }while(opcao < 1  ||  opcao > 4);
   fflush(stdin);
   return opcao;
}

/*----------------------------------------------------------------------*/
void pausa(void) {
/*
Objetivo  : fazer uma pausa no processamento.
Argumentos: nenhum.
Retorno   : nenhum.
*/
   printf("Tecle ENTER para continuar...");
   getchar();
}

/*----------------------------------------------------------------------*/
int carrega(char *nomeArquivo, Lista *lista) {
/*
Objetivo  : copiar os registros da memoria auxiliar (arquivo: nome) para a
            memoria principal (vetor de poteiros: dados).
Argumentos: nomeArquivo - nome do arquivo que contem os registros.
            lista - ponteiro para estrutura do tipo Lista que contem os registros e a qtde.
Retorno   : 1 se tudo ok, ou zero se arquivo nao pôde ser criado/aberto.
*/
   char aux[10];
   FILE *fp;
   // se o arquivo não existe
   if((fp = fopen(nomeArquivo,"r")) == 0) {
      printf("Arquivo %s nao encontrado, Deseja cria-lo ? (s/n) ", nomeArquivo);
      gets(aux);
      if( aux[0] == 's' ||  aux[0] == 'S') {
         if((fp = fopen(nomeArquivo,"w")) == 0) {
            printf("Arquivo %s nao pode ser criado", nomeArquivo);
            return 0;
         }
         else {
            printf("%s foi criado com sucesso!\n", nomeArquivo);
            pausa();
            return 1;
         }
      }
      // se o usuário não quer criar, retorna com código zero
      else
         return 0;
   }
   // se o arquivo existe, então le os seus dados
   int i = 0, status;
   while(1) {
      // malloc retorna zero se não há memória disponível
      if( !(lista->vetor[i]=(Registro*)malloc(sizeof(Registro))) ) {
         printf("\n\nFalta memoria !\n");
         return 0;
      }
      /* fscanf retorna qtde de informacoes lidas, ou EOF */
      status = fscanf(fp, "%30s %8s %d %d %d %f", lista->vetor[i]->nome,
               lista->vetor[i]->tel,  &lista->vetor[i]->dia, &lista->vetor[i]->mes,
               &lista->vetor[i]->ano, &lista->vetor[i]->valor);
      if(status == EOF)
         break;
      i++;
   }
   fclose(fp);
   printf("%d registro(s) recurerado(s)\n", i);
   lista->qtde = i;
   pausa();
   return 1;
}

/*----------------------------------------------------------------------*/
void inclui(Lista *lista) {
/*
Objetivo  : incluir novos registros no vetor de ponteiros.
Argumentos: lista - ponteiro para estrutura do tipo Lista que contem os registros e a qtde.
Retorno   : nenhum.
*/
   char aux[MAX_NOME];
   int i = lista->qtde;
   while(1) {
      printf("\n\n\n\t\tENTRADA DE DADOS");
      printf("\n\nREGISTRO: %d", i+1);
      printf("\nEntre com o nome (maximo 30 caracteres) - ENTER sai: ");
      fflush(stdin);
      gets(aux);
      if(strlen(aux) == 0)
         break;
      // se nome não foi vazio, aloca memória para mais um elemento na lista:
      if( !(lista->vetor[i]=(Registro*)malloc(sizeof(Registro))) ) {
         printf("\n\nFalta memoria !\n");
         break;
      }
      // preenche a memória alocada
      strcpy(lista->vetor[i]->nome, aux);
      printf("Entre com o telefone (maximo 8 caracteres): ");
      gets(lista->vetor[i]->tel);
      printf("Entre com a data de nascimento (formato dd mm aa): ");
      scanf("%d %d %d",&lista->vetor[i]->dia, &lista->vetor[i]->mes, &lista->vetor[i]->ano);
      printf("Entre com o valor: ");
      scanf("%f", &lista->vetor[i]->valor);
      i++;
   }
   // atualiza a qtde de registros da lista
   lista->qtde = i;
}

/*----------------------------------------------------------------------*/
int salva(char *nomeArquivo, Lista *lista) {
/*
Objetivo  : salvar os registros para a memoria auxiliar.
Argumentos: nomeArquivo - nome do arquivo que ira armazenar os registros.
            lista - ponteiro para estrutura do tipo Lista que contem os registros e a qtde
Retorno   : 0 se o arquivo nao pode ser criado/aberto, ou 1 se ok.
*/
   int i;
   FILE *fp;

   if((fp = fopen(nomeArquivo,"w")) == 0){
      printf("Erro em %s, os dados nao foram salvos", nomeArquivo);
      pausa();
      return 0;
   }
   for (i = 0; i < lista->qtde; i++)
      // "%-30s" alinha o nome a esquerda dentro de 30 espaços
      // "%02d" preenche com zeros a esquerda em dois dígitos
      fprintf(fp, "%-30s %-8s %02d %02d %02d %7.3f\n",lista->vetor[i]->nome,
              lista->vetor[i]->tel, lista->vetor[i]->dia, lista->vetor[i]->mes,
              lista->vetor[i]->ano, lista->vetor[i]->valor);
   fclose(fp);
   printf("%d registro(s) gravado(s)\n", lista->qtde);
   return 1;
}

/*----------------------------------------------------------------------*/
void exibeLista(Lista *lista) {
/*
Objetivo  : exibir todos os registros que estao no vetor
Argumentos: lista - ponteiro para estrutura do tipo Lista que contem os registros e a qtde
Retorno   : nenhum.
*/
   int i;

   printf("\n\n\n-----------------------------------------------------"
          "---------------\nDados cadastrados:\n\nNo  Nome"
          "                           Telefone"
          "      Data          Valor\n\n");
   for(i = 0; i < lista->qtde; i++) {
      printf("%d - ",i+1);
      exibeRegistro(lista->vetor[i]);
   }
   printf("\n-----------------------------------------------------"
          "---------------\n");
   pausa();
   printf("\n\n");
}

/*----------------------------------------------------------------------*/
void exibeRegistro(Registro *reg) {
/*
Objetivo  : exibir um registro
Argumentos: reg - ponteiro para o registro que será exibido.
Retorno   : nenhum.
*/
   printf("%-30s %-8s      %02d/%02d/%02d    %7.3f\n",
          reg->nome, reg->tel, reg->dia, reg->mes, reg->ano, reg->valor);
}