// Inclusão de bibliotecas de funções prontas em C.
#include <stdio.h> // entrada e saÃda de dados do usuário.
#include <time.h> // manipula o relógio do sistema.
#include <string.h>
// Primeira parte do programa:
// - declaração das estruturas de dados
struct evento
{
char titulo[50]; // TÃtulo do evento
char dataDeInicio[11]; // Data de inÃcio
char horarioDeInicio[6]; // Horário de inÃcio
char dataDeTermino[11]; // Data de término
char horarioDeTermino[6]; // Horário de término
char dataDeCriacao[11]; // Data de criação do evento (1 byte a mais para \0)
char horarioDeCriacao[6]; // Hora de criação do evento (1 byte a mais para \0)
char descricao[100]; // Um texto explicativo do evento
char local[100]; // Local de realização
char estado[20]; // Estados: confirmado, a confirmar, etc.
char categoria[10]; // Categoria: pessoal, trabalho, etc.
char recorrencia[20]; // Quantas vezes se repete?
char linha[500];
char *leu;
};
// Segunda parte do programa:
// - funções auxiliares
//
// função dia_mes_ano(): mostra a data atual do relógio do sistema
char* dia_mes_ano(char * data)
{
time_t agora;
struct tm ts;
agora = time(NULL);
ts = *localtime(&agora);
strftime(data, 11, "%d/%m/%Y", &ts);
}
//
// função hora_minuto(): mostra a hora atual do relógio do sistema
char* hora_minuto(char * data)
{
time_t agora;
struct tm ts;
agora = time(NULL);
ts = *localtime(&agora);
strftime(data, 6, "%H:%M", &ts);
}
//
// função lerNumero(): lê um número via teclado do usuário
int lerNumero()
{
int numero;
int leuNumero = 1;
do
{
if (leuNumero == 0)
{
printf("Ops! Problemas ao ler o número. Digite-o novamente: ");
}
leuNumero = scanf("%d", &numero); // Se aparecer algo diferente de número
if (leuNumero == 0) // A função retornará zero.
{
leuNumero = scanf("%*[^\n]"); // Ou seja, "sujeira" como uma vogal.
}
} while (leuNumero == 0); // E a função não encerrará até que o
return numero; // digite, mesmo, um número.
}
//
// função lerLinha: lê uma linha inteira até o usuário digitar <ENTER>
void lerLinha(char* linha)
{
scanf(" %[^\n]", linha); // Com isso, lê-se uma linha inteira.
}
// Função principal
// Ã aqui em que se define, de fato, o programa.
int main()
{
FILE *arq1;
char nomeDoArquivo[100];
char linha[500];
char *leu;
char *auxiliar;
int opcao; // opção do usuário: criar evento, ler, etc.
int indice = 0; // quantidade de eventos já cadastrados; ou seja, nenhum (0).
int indiceTemporario; // índice temporário, baseado na variável índice.
struct evento eventos[100]; // até 100 eventos possÃveis.
// O programa vai mostrar o menu indefinidamente.
// O usuário escolherá quando parar.
do
{
// Menu de opções
printf("\n\nOpção 1: criar um evento.\n");
printf("Opção 2: mostrar um evento já criado.\n");
printf("Opção 3: gravar os eventos em um arquivo.\n");
printf("Opção 4: Leitura e escrita de um arquivo.\n");
printf("Opção 5: Sair do programa.\n");
printf("Digite a sua opção: ");
//
// O usuário escolhe a opção.
opcao = lerNumero();
printf("\n");
//
// Para cada opção, um conjunto de instruções a executar.
switch(opcao)
{
// Opção 1: criar um evento.
case 1:
printf("\nSobre o evento, informe:\n");
printf("Título: ");
lerLinha(eventos[indice].titulo);
printf("Data de início (dia/mês/ano):");
lerLinha(eventos[indice].dataDeInicio);
printf("Hora de início (hora:minuto):");
lerLinha(eventos[indice].horarioDeInicio);
printf("Data de término (dia/mês/ano):");
lerLinha(eventos[indice].dataDeTermino);
printf("Hora de término (hora:minuto):");
lerLinha(eventos[indice].horarioDeTermino);
dia_mes_ano(eventos[indice].dataDeCriacao); // automático: data do sistema
hora_minuto(eventos[indice].horarioDeCriacao); // automático: hora do sistema
printf("Descrição:");
lerLinha(eventos[indice].descricao);
printf("Local de realização:");
lerLinha(eventos[indice].local);
printf("Estado (confirmado, a confirmar, etc):");
lerLinha(eventos[indice].estado);
printf("Categoria (pessoal, estudos, trabalho, etc):");
lerLinha(eventos[indice].categoria);
printf("Recorrência (taxa de repetição):");
lerLinha(eventos[indice].recorrencia);
indice = indice + 1; // Um evento foi adicionado. Incrementa o indice.
break;
// Opção 2: mostrar um evento já cadastrado.
case 2:
if(indice == 0)
{
printf("Não há eventos cadastrados.\n");
}
else
{
printf("Há %d eventos cadastrados.\n", indice);
printf("Escolha um evento entre 0 e %d: ",indice-1);
opcao = lerNumero();
if (opcao < 0 || opcao > indice)
{
printf("Número fora dos limites.\n");
}
else
{
printf("\nEvento número: %d\n", opcao);
printf("Título: %s\n", eventos[opcao].titulo);
printf("Data de início: %s\n", eventos[opcao].dataDeInicio);
printf("Hora de início: %s\n", eventos[opcao].horarioDeInicio);
printf("Data de término: %s\n", eventos[opcao].dataDeTermino);
printf("Hora de término: %s\n", eventos[opcao].horarioDeTermino);
printf("Data de criação: %s\n", eventos[opcao].dataDeCriacao);
printf("Hora de criação: %s\n", eventos[opcao].horarioDeCriacao);
printf("Descrição: %s\n", eventos[opcao].descricao);
printf("Local de realização: %s\n", eventos[opcao].local);
printf("Estado: %s\n", eventos[opcao].estado);
printf("Categoria: %s\n", eventos[opcao].categoria);
printf("Recorrência: %s\n", eventos[opcao].recorrencia);
}
}
break;
// Opção padrão: é interessante criar uma opção padrão para
// informar o usuário quando ele digita um número fora da lista
// de opções. Neste caso, 1 > número > 3.
case 3:
printf("Informe o nome completo do arquivo: ");
lerLinha(nomeDoArquivo);
arq1 = fopen("/home/aluno/Desktop/teste.txt", "w");
if (arq1)
{
for(indiceTemporario=0; indiceTemporario < indice; indiceTemporario++)
{
printf("Gravando evento número %d...\n", indiceTemporario); // vai pra tela (printf)
// fprintf(arq1, "Evento número %d:\n", indiceTemporario); // vai pro arquivo (fprintf)
fprintf(arq1, "Título: %s\n", eventos[indiceTemporario].titulo);
fprintf(arq1, "Data de Incício: %s\n", eventos[indiceTemporario].dataDeInicio);
fprintf(arq1, "Hora de Início: %s\n", eventos[indiceTemporario].horarioDeInicio);
fprintf(arq1, "Data de Termino do evento: %s\n", eventos[indiceTemporario].dataDeTermino);
fprintf(arq1, "Horário de termino: %s\n", eventos[indiceTemporario].horarioDeTermino);
fprintf(arq1, "Data de criação: %s\n", eventos[indiceTemporario].dataDeCriacao);
fprintf(arq1, "Hora de Criação: %s\n", eventos[indiceTemporario].horarioDeCriacao);
fprintf(arq1, "Descrição do evento: %s\n", eventos[indiceTemporario].descricao);
fprintf(arq1, "Local do evento: %s\n", eventos[indiceTemporario].local);
fprintf(arq1, "Estado: %s\n", eventos[indiceTemporario].estado);
fprintf(arq1, "Categoria do evento: %s\n", eventos[indiceTemporario].categoria);
fprintf(arq1, "Recorrência: %s\n", eventos[indiceTemporario].recorrencia);
}
fclose(arq1);
printf("Arquivo %s gravado com sucesso.\n", nomeDoArquivo);
}
break;
case 4:
printf("Informe o nome completo do arquivo: ");
lerLinha(nomeDoArquivo);
printf("\n");
// arq1 = fopen(nomeDoArquivo, "r");
arq1 = fopen("/home/aluno/Desktop/teste.txt", "r");
if(arq1)
{
indice = 0; // começa a ler o primeiro evento...
do
{
if (fgets(linha, sizeof(linha), arq1))
{
auxiliar = strchr(linha,':');
strcpy(eventos[indice].titulo,auxiliar+2);
printf("Título do evento número %d= %s", indice, eventos[indice].titulo);
}
if (fgets(linha, sizeof(linha), arq1))
{
auxiliar = strchr(linha,':');
strcpy(eventos[indice].dataDeInicio,auxiliar+2);
printf("Data de início do evento número %d= %s", indice, eventos[indice].dataDeInicio);
}
if (fgets(linha, sizeof(linha), arq1))
{
auxiliar = strchr(linha,':');
strcpy(eventos[indice].horarioDeInicio,auxiliar+2);
printf("Hora de Incício %d= %s", indice, eventos[indice].horarioDeInicio);
}
if (fgets(linha, sizeof(linha), arq1))
{
auxiliar = strchr(linha,':');
strcpy(eventos[indice].dataDeTermino,auxiliar+2);
printf("Data de Termino do evento %d= %s", indice, eventos[indice].dataDeTermino);
}
if (fgets(linha, sizeof(linha), arq1))
{
auxiliar = strchr(linha,':');
strcpy(eventos[indice].horarioDeTermino,auxiliar+2);
printf("Horário de termino %d= %s", indice, eventos[indice].horarioDeTermino);
}
if (fgets(linha, sizeof(linha), arq1))
{
auxiliar = strchr(linha,':');
strcpy(eventos[indice].dataDeCriacao,auxiliar+2);
printf("Data de criação %d= %s", indice, eventos[indice].dataDeCriacao);
}
if (fgets(linha, sizeof(linha), arq1))
{
auxiliar = strchr(linha,':');
strcpy(eventos[indice].horarioDeCriacao,auxiliar+2);
printf("Hora de Criação %d= %s", indice, eventos[indice].horarioDeCriacao);
}
if (fgets(linha, sizeof(linha), arq1))
{
auxiliar = strchr(linha,':');
strcpy(eventos[indice].descricao,auxiliar+2);
printf("Descrição do evento %d= %s", indice, eventos[indice].descricao);
}
if (fgets(linha, sizeof(linha), arq1))
{
auxiliar = strchr(linha,':');
strcpy(eventos[indice].local,auxiliar+2);
printf("Local do evento %d= %s", indice, eventos[indice].local);
}
if (fgets(linha, sizeof(linha), arq1))
{
auxiliar = strchr(linha,':');
strcpy(eventos[indice].estado,auxiliar+2);
printf("Estado %d= %s", indice, eventos[indice].estado);
}
if (fgets(linha, sizeof(linha), arq1))
{
auxiliar = strchr(linha,':');
strcpy(eventos[indice].categoria,auxiliar+2);
printf("Categoria do evento %d= %s", indice, eventos[indice].categoria);
}
if (fgets(linha, sizeof(linha), arq1))
{
auxiliar = strchr(linha,':');
strcpy(eventos[indice].recorrencia,auxiliar+2);
printf("Recorrência %d= %s", indice, eventos[indice].recorrencia);
}
// .. próximos itens de cada evento...
indice = indice + 1; // vai para o próximo evento...
printf("\n");
} while (! feof(arq1));
fclose(arq1);
}
else
{
printf("ATENÇÃO! Não é possível abrir o arquivo %s para leitura.\n", nomeDoArquivo);
}
printf("\nDeseja mudar o seu conteúdo?\n");
printf("1 - Sim\n");
printf("2 - Não\n");
opcao = lerNumero();
switch(opcao)
{
case 1:
arq1 = fopen("/home/aluno/Desktop/teste.txt", "w");
if(arq1)
{
printf("Digite quantas frases quiser.\n");
printf("Para terminar, digite uma linha");
printf(" contendo apenas a expressão \"EOF\":\n");
do
{
lerLinha(linha);
if(strcmp(linha,"EOF") != 0) // as string são diferentes
{
fprintf(arq1, "%s\n", linha);
}
} while (strcmp(linha,"EOF"));
fclose(arq1);
}
else
{
printf("ATENÇÃO! Não é possível abrir o arquivo %s para escrita.\n", nomeDoArquivo);
}
break;
case 2:
printf("Preservando o conteúdo original...\n");
break;
default:
printf("Número inválido.\n");
}
break;
// Opção 3: sair do programa.
case 5:
printf("Fim do programa. Adeus!\n");
break;
default:
printf("Por favor, escolha um número entre 1 e 3.\n");
// Essa estrutura de repetição (do..while) rodará enquanto a opção
// for diferente de 3.
} // fim do switch(opcao)
} while (opcao != 5);
}
//Inclusão de outros arquivos e bibliotecas
#include <stdio.h>
#include <time.h>
#include<string.h>
//Estruturas de dados
// Estrutura de um evento:
// - Título
// - Data de início e de fim
// - Horário de início e de fim
// - Data e horário de criação
// - descrição
// - local
// - estado: confirmado ou não?
// - categoria: pessoal, trabalho, etc.
// - recorrência: regularidade.
struct evento
{
char titulo[50];
char dataDeInicio[10];
char dataDeTermino[10];
char horarioDeInicio[5];
char horarioDeTermino[5];
char dataDeCriacao[10];
char horaDeCriacao[5];
char descricao[100];
char local[100];
char estado[20];
char categoria[10];
char recorrencia[20];
};
//Funções auxiliares
//
// função lerNumero(): lê um número via teclado do usuário
int lerNumero()
{
int numero;
int leuNumero = 1;
do
{
if (leuNumero == 0)
{
printf("Preste mais atenção!Você digitou um numero errado. Digite-o novamente: ");
}
leuNumero = scanf("%d", &numero); // Se aparecer algo diferente de número
if (leuNumero == 0) // A função retornará zero.
{
leuNumero = scanf("%*[^\n]"); // Ou seja, "sujeira" como uma vogal.
}
} while (leuNumero == 0); // E a função não encerrará até que o
return numero; // digite, mesmo, um número.
}
// função lerNumero(): lê um número via teclado do usuário
int lerNumero();
int numero;
int leuNumero = 1;
{
do
{
if (leuNumero == 0)
{
printf("Ops! Problemas ao ler o número. Digite-o novamente: ");
}
leuNumero = scanf("%d", &numero);
if (leuNumero == 0)
{
leuNumero = scanf("%*[^\n]");
}
} while (leuNumero == 0);
return numero;
}
//Função ler linha
void lerLinha(char* linha)
{
scanf(" %[^\n]", linha);
}
//Função Hora atual
//Função principal
int main()
{
int visualizar;
int indice;
char* hora;
FILE *arq1;
char nomeDoArquivo[100];
char linha[500];
char *leu;
int senha;
int opcao;
// Cadastro de banco de dados:
printf("Digite seu Login com apenas 6 caracteres e sem acento: ");
lerLinha(nomeDoArquivo);
arq1 = fopen(nomeDoArquivo, "r");
if(arq1)
{
do
{
printf("\nBanco de dados encontrado, Digite sua senha: \n");
fgets(linha, sizeof(linha), arq1);
senha = lerNumero();
} while (atoi(linha) != senha);
}
else
{
printf("\nBanco de dados não cadastrado. Deseja cadastrar uma nova agenda?\n");
printf("1 - Sim\n");
printf("2 - Não\n");
opcao = lerNumero();
switch(opcao)
{
case 1:
arq1 = fopen(nomeDoArquivo, "w");
if(arq1)
{
printf("Digite sua senha com apenas 4 dígitos: ");
senha = lerNumero();
fprintf(arq1, "%d\n", senha);
fclose(arq1);
}
else
{
printf("ATENÇÃO! Não é possível abrir o arquivo %s para escrita.\n", nomeDoArquivo);
}
break;
}
}
}
//Função Hora atual
char* agora()
{
time_t hora;
time(&hora);
return(ctime(&hora));
}
//Função principal
int main()
{
int visualizar;
int opcao;
int indice;
char* hora;
struct evento meuPrimeiroEvento[4];
indice = 1;
do
{
printf("\nOpção 1: criar um evento.\n");
printf("Opção 2: mostar um evento já criado.\n");
printf("Opção 3: Sair do programa.\n");
printf("Digite a sua opção: ");
opcao = lerNumero();
switch(opcao)
{
case 1:
hora = agora();
printf("\n===========================================\n");
printf("Seu evento foi cadastrado com numero: %d\n", indice);
printf("Grave este numero para poder visualiza-lo.\n");
printf("===========================================\n");
printf("Digite o título do evento: ");
scanf("%s", meuPrimeiroEvento[indice].titulo);
printf("Digite a data de inicio: ");
scanf("%s", meuPrimeiroEvento[indice].dataDeInicio);
printf("Digite a data de termino: ");
scanf("%s", meuPrimeiroEvento[indice].dataDeTermino);
printf("Digite o horario de inicio: ");
scanf ("%s", meuPrimeiroEvento[indice].horarioDeInicio);
printf("Digite o horario de termino: ");
scanf("%s", meuPrimeiroEvento[indice].horarioDeTermino);
printf("Digite a data de crição: ");
scanf("%s", meuPrimeiroEvento[indice].horaDeCriacao);
printf("Digite a descriacao do evento: ");
scanf("%s", meuPrimeiroEvento[indice].descricao);
printf("Digite o local do evento: ");
scanf("%s", meuPrimeiroEvento[indice].local);
printf("Categoria (pessoal,aulas, trabalho entre outros) : ");
scanf("%s", meuPrimeiroEvento[indice].categoria);
printf("Recorrência (taxa de repetição): ");
scanf("%s", meuPrimeiroEvento[indice].recorrencia);
indice++;
break;
case 2:
printf("\nDigite o numero do evento que deseja visualizar:");
scanf("%d", &visualizar);
printf("\n===========================================");
printf("\nTítulo: %s\n", meuPrimeiroEvento[visualizar].titulo);
printf("Data de Inicio: %s\n", meuPrimeiroEvento[visualizar].dataDeInicio);
printf("Data de termino: %s\n",meuPrimeiroEvento[visualizar].dataDeTermino);
printf("Horario de inicio: %s\n",meuPrimeiroEvento[visualizar].horarioDeInicio);
printf("Horario de termino: %s\n",meuPrimeiroEvento[visualizar].horarioDeTermino);
printf("Data de criacao: %s\n",meuPrimeiroEvento[visualizar].horaDeCriacao);
printf("Descricao do evento: %s\n",meuPrimeiroEvento[visualizar].descricao);
printf("Local do evento: %s\n",meuPrimeiroEvento[visualizar].local);
printf("Categoria: %s\n",meuPrimeiroEvento[visualizar].categoria);
printf("Recorrencia: %s\n",meuPrimeiroEvento[visualizar].recorrencia);
printf("Hora de criação: %s", agora());
printf("Hora de Criacao: %s", hora);
printf("===========================================");
break;
case 3:
printf("Fim do programa. Adeus!\n");
break;
}
} while (opcao != 3);
}
...
{
printf("N√∫mero fora dos limites.\n");
}
else
{
printf("\nEvento n√∫mero: %d\n", opcao);
printf("Título: %s\n", eventos[opcao].titulo);
printf("Data de início: %s\n", eventos[opcao].dataDeInicio);
printf("Hora de início: %s\n", eventos[opcao].horarioDeInicio);
printf("Data de término: %s\n", eventos[opcao].dataDeTermino);
printf("Hora de término: %s\n", eventos[opcao].horarioDeTermino);
printf("Data de criação: %s\n", eventos[opcao].dataDeCriacao);
printf("Hora de criação: %s\n", eventos[opcao].horarioDeCriacao);
printf("Descrição: %s\n", eventos[opcao].descricao);
printf("Local de realização: %s\n", eventos[opcao].local);
printf("Estado: %s\n", eventos[opcao].estado);
printf("Categoria: %s\n", eventos[opcao].categoria);
printf("Recorrência: %s\n", eventos[opcao].recorrencia);
}
}
break;
// Opção 3: sair do programa.
case 3:
printf("Fim do programa. Adeus!\n");
break;
// Opção padrão: é interessante criar uma opção padrão para
// informar o usu√°rio quando ele digita um n√∫mero fora da lista
// de opções. Neste caso, 1 > número > 3.
default:
printf("Por favor, escolha um n√∫mero entre 1 e 3.\n");
}
// Essa estrutura de repetição (do..while) rodará enquanto a opção
// for diferente de 3.
} while (opcao != 3);
}
// Bibliotecas de C
#include <stdio.h> // entrada e saída padrão
#include <time.h> // relógio do sistema
#include <string.h>
// Estruturas de dados
struct evento
{
char titulo[50]; // Título do evento
char dataDeInicio[11]; // Data de início
char horarioDeInicio[6]; // Horário de início
char dataDeTermino[11]; // Data de término
char horarioDeTermino[6]; // Horário de término
char dataDeCriacao[11]; // Data de criação do evento (1 byte a mais para \0)
char horarioDeCriacao[6]; // Hora de criação do evento (1 byte a mais para \0)
char descricao[100]; // Um texto explicativo do evento
char local[100]; // Local de realização
char estado[20]; // Estados: confirmado, a confirmar, etc.
char categoria[10]; // Categoria: pessoal, trabalho, etc.
char recorrencia[20]; // Quantas vezes se repete?
};
// Funções auxiliares
//
// função dia_mes_ano(): mostra a data atual do relógio do sistema
char* dia_mes_ano(char * data)
{
time_t agora;
struct tm ts;
agora = time(NULL);
ts = *localtime(&agora);
strftime(data, 11, "%d/%m/%Y", &ts);
}
//
// função hora_minuto(): mostra a hora atual do relógio do sistema
char* hora_minuto(char * data)
{
time_t agora;
struct tm ts;
agora = time(NULL);
ts = *localtime(&agora);
strftime(data, 6, "%H:%M", &ts);
}
//
// função lerNumero(): lê um número via teclado do usuário
int lerNumero()
{
int numero;
int leuNumero = 1;
do
{
if (leuNumero == 0)
{
printf("Ops! Problemas ao ler o número. Digite-o novamente: ");
}
leuNumero = scanf("%d", &numero); // Se aparecer algo diferente de número
if (leuNumero == 0) // A função retornará zero.
{
leuNumero = scanf("%*[^\n]"); // Ou seja, "sujeira" como uma vogal.
}
} while (leuNumero == 0); // E a função não encerrará até que
return numero; // se digite um número.
}
//
// função lerLinha(): lê uma linha inteira até o usuário digitar <ENTER>
void lerLinha(char* linha)
{
scanf(" %[^\n]", linha); // Com isso, lê-se uma linha inteira.
}
// Função para retirar o enter das frases.
void linhaDoArquivo(FILE *arquivo, char * linha){
char *auxiliar;
char nomeDoArquivo[50];
//arquivo = fopen(nomeDoArquivo,"r");
fgets(linha, 500, arquivo);
if(auxiliar = strchr(linha, '\n'))
auxiliar[0] = '\0';
//fclose(arquivo);
}
// Função principal. É aqui em que se define, de fato, o programa.
int main()
{
// Variáveis do programa
FILE *arq1;
int indiceAuxiliar = 0;
int opcao; // opção do usuário: criar evento, ler, etc.
int indice = 0; // quantidade de eventos já cadastrados; ou seja, nenhum (0).
char nomeDoArquivo[20];// tamanho do nome do arquivo a ser salvo.
char *leu;
char lido[100];
char linha[500];
struct evento eventos[100]; // até 100 eventos possíveis.
// O programa vai mostrar o menu indefinidamente.
// O usuário escolherá quando parar.
do
{
// Menu de opções
printf("\n\nOpção 1: Criar um evento.\n");
printf("Opção 2: Abrir um evento já criado.\n");
printf("Opção 3: Gravar evento.\n");
printf("Opção 4: Sair do programa.\n");
printf("Digite a sua opção: ");
//
// O usuário escolhe a opção.
opcao = lerNumero();
//
// Para cada opção, um conjunto de instruções a executar.
switch (opcao)
{
// Opção 1: criar um evento.
case 1:
printf("\nSobre o evento, informe:\n");
printf("Título: ");
lerLinha(eventos[indice].titulo);
printf("Data de início (dia/mês/ano): ");
lerLinha(eventos[indice].dataDeInicio);
printf("Hora de início (hora:minuto): ");
lerLinha(eventos[indice].horarioDeInicio);
printf("Data de término (dia/mês/ano): ");
lerLinha(eventos[indice].dataDeTermino);
printf("Hora de término (hora:minuto): ");
lerLinha(eventos[indice].horarioDeTermino);
dia_mes_ano(eventos[indice].dataDeCriacao); // automático: data do sistema
hora_minuto(eventos[indice].horarioDeCriacao); // automático: hora do sistema
printf("Descrição: ");
lerLinha(eventos[indice].descricao);
printf("Local de realização: ");
lerLinha(eventos[indice].local);
printf("Estado (confirmado, a confirmar, etc): ");
lerLinha(eventos[indice].estado);
printf("Categoria (pessoal, estudos, trabalho, etc): ");
lerLinha(eventos[indice].categoria);
printf("Recorrência (taxa de repetição): ");
lerLinha(eventos[indice].recorrencia);
indice = indice + 1; // Um evento foi adicionado. Incrementa o indice.
break;
case 2:
printf("Digite o nome do Arquivo: ");
lerLinha(nomeDoArquivo);
arq1 = fopen(nomeDoArquivo, "r");
indice = 0;
if(arq1)
{
do
{
linhaDoArquivo(arq1, lido);
printf("%s\n", lido);
} while (! feof(arq1));
printf("Fim do arquivo %s.......\n", nomeDoArquivo);
}
else
{
printf("Não existe este evento!");
return 0;
}
break;
// Opção 3: Gravar o evento.
case 3:
printf("Por favor digite o nome do arquivo para gravar os eventos: ");
lerLinha(nomeDoArquivo);
arq1 = fopen(nomeDoArquivo, "w");
if(arq1)
{
printf("Iniciando gravação...\n");
for (indiceAuxiliar = 0; indiceAuxiliar < indice; indiceAuxiliar ++)
{
printf("Gravando evento número %d.\n", indiceAuxiliar);
fprintf(arq1, "%s\n", eventos[indiceAuxiliar].titulo);
fprintf(arq1, "%s\n", eventos[indiceAuxiliar].dataDeInicio);
fprintf(arq1, "%s\n", eventos[indiceAuxiliar].horarioDeInicio);
fprintf(arq1, "%s\n", eventos[indiceAuxiliar].dataDeTermino);
fprintf(arq1, "%s\n", eventos[indiceAuxiliar].horarioDeTermino);
fprintf(arq1, "%s\n", eventos[indiceAuxiliar].dataDeCriacao);
fprintf(arq1, "%s\n", eventos[indiceAuxiliar].horarioDeCriacao);
fprintf(arq1, "%s\n", eventos[indiceAuxiliar].descricao);
fprintf(arq1, "%s\n", eventos[indiceAuxiliar].local);
fprintf(arq1, "%s\n", eventos[indiceAuxiliar].estado);
fprintf(arq1, "%s\n", eventos[indiceAuxiliar].categoria);
fprintf(arq1, "%s\n", eventos[indiceAuxiliar].recorrencia);
}
fclose(arq1);
arq1 = fopen(nomeDoArquivo,"r");
if(arq1)
{
do
{
leu = fgets(linha, sizeof(linha), arq1);
if(leu)
{
printf("%s", linha);
}
} while (! feof(arq1));
printf("Fim do arquivo %s.......\n", nomeDoArquivo);
fclose(arq1);
}
printf("Eventos gravados com sucesso!\n");
}
break;
// Opção 4: sair do programa.
case 4:
printf("Fim do programa. Adeus!\n");
break;
// Opção padrão: é interessante criar uma opção padrão para
// informar o usuário quando ele digita um número fora da lista
// de opções. Neste caso, 1 > número > 3.
default:
printf("Por favor, escolha um número entre 1 e 4.\n");
}
// Essa estrutura de repetição (do..while) rodará enquanto a opção
// for diferente de 4.
}
while (opcao != 4);
}