Sistemas Operacionais e Introdução a Programação (diário 2009-2) - Defesa do código final
Ir para navegação
Ir para pesquisar
Alysson e Deivid
// 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);
}
Barbara e Rafael Luchi
//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);
}
Bruno
#include <stdio.h>
#include <time.h>
#include <string.h>
struct evento {
char titulo[20];
char dataDeInicio[11];
char dataDeCriacao[11];
char dataDeFim[11];
char horarioDeInicio[6];
char horarioDeCriacao[6];
char horarioDeFim[6];
char descricao[100];
char local[100];
char estado[20]; // confirmado ou nao....
char categoria[10]; // se é do ifsc ou de outro evento...
char recorrencia[20]; //diario, semanal...
};
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);
}
char* hora_minuto(char * data) {
time_t agora;
struct tm ts;
agora = time(NULL);
ts = *localtime(&agora);
strftime(data, 6, "%H:%M", &ts);
}
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;
}
void lerLinha(char* linha) {
scanf(" %[^\n]", linha); // Com isso, lê-se uma linha inteira.
}
int main() {
int opcao;
int indice = 0;
int indiceAuxiliar = 0;
FILE *arq1;
char nomeDoArquivo[100];
char linha[500];
char *leu;
int opcaoA;
int opcaoB;
char * linhaa;
char * auxiliar;
struct evento eventos[100];
do {
printf("Opção 1: Criar um evento. \n");
printf("Opção 2: Mostrar evento(s) já criado(s). \n");
printf("Opção 3: Gravar todos os eventos em um arquivo. \n");
printf("Opção 4: Manipular arquivos existentes. \n");
printf("Opção 5: Sair do programa. \n");
printf("Digite a opção: ");
opcao = lerNumero();
switch (opcao) {
case 1:
printf("Didite o titulo do evento: ");
lerLinha(eventos[indice].titulo);
printf("Digite a data de início: ");
lerLinha(eventos[indice].dataDeInicio);
printf("Digite a data de fim: ");
lerLinha(eventos[indice].dataDeFim);
printf("Digite o horário de início: ");
lerLinha(eventos[indice].horarioDeInicio);
dia_mes_ano(eventos[indice].dataDeCriacao);
hora_minuto(eventos[indice].horarioDeCriacao);
printf("Digite o horário de fim: ");
lerLinha(eventos[indice].horarioDeFim);
printf("Digite a descrição do evento: ");
lerLinha(eventos[indice].descricao);
printf("Digite o local: ");
lerLinha(eventos[indice].local);
printf("Digite o estado: ");
lerLinha(eventos[indice].estado);
printf("Digite o categoria: ");
lerLinha(eventos[indice].categoria);
printf("Digite o recorrencia: ");
lerLinha(eventos[indice].recorrencia);
indice = indice + 1;
break;
case 2:
if (indice == 0) {
printf("Não há nenhum evento cadastrado.\n");
} else {
printf("Há %d evento(s) 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");
}
printf("Apenas um evento cadastrado. \n");
printf("Titulo:%s \n", eventos[opcao].titulo);
printf("Data de início: %s \n", eventos[opcao].dataDeInicio);
printf("Data de criação: %s \n", eventos[opcao].dataDeCriacao);
printf("Data de fim: %s \n", eventos[opcao].dataDeFim);
printf("Hora de início: %s \n", eventos[opcao].horarioDeInicio);
printf("Hora de criação: %s \n", eventos[opcao].horarioDeCriacao);
printf("Término: %s \n", eventos[opcao].horarioDeFim);
printf("Descrição: %s \n", eventos[opcao].descricao);
printf("Local: %s \n", eventos[opcao].local);
printf("Confirmação: %s \n", eventos[opcao].estado);
printf("Categoria do evento: %s \n", eventos[opcao].categoria);
printf("Recorrência: %s \n", eventos[opcao].recorrencia);
break;
case 3:
printf("Informe o nome completo do arquivo: ");
lerLinha(nomeDoArquivo);
arq1 = fopen(nomeDoArquivo, "w");
if (arq1) {
printf("Iniciando gravação...");
for (indiceAuxiliar = 0; indiceAuxiliar < indice; indiceAuxiliar++) {
printf("Gravando evento numero %d.\n", indiceAuxiliar);
printf("Saving.. \n");
printf(".........\n");
printf("..........\n");
printf("...........\n");
printf("............\n");
fprintf(arq1, "Título: %s\n", eventos[indiceAuxiliar].titulo);
fprintf(arq1, "Data de inicio: %s\n", eventos[indiceAuxiliar].dataDeInicio);
fprintf(arq1, "Data de criação: %s\n", eventos[indiceAuxiliar].dataDeCriacao);
fprintf(arq1, "Data de término: %s\n", eventos[indiceAuxiliar].dataDeFim);
fprintf(arq1, "Horário de início: %s\n", eventos[indiceAuxiliar].horarioDeInicio);
fprintf(arq1, "Horário de criação: %s\n", eventos[indiceAuxiliar].horarioDeCriacao);
fprintf(arq1, "Horário de término: %s\n", eventos[indiceAuxiliar].horarioDeFim);
fprintf(arq1, "Descrição: %s\n", eventos[indiceAuxiliar].descricao);
fprintf(arq1, "Local: %s\n", eventos[indiceAuxiliar].local);
fprintf(arq1, "Estado de confirmação: %s\n", eventos[indiceAuxiliar].estado);
fprintf(arq1, "Categoria: %s\n", eventos[indiceAuxiliar].categoria);
fprintf(arq1, "Recorrência do evento: %s\n", eventos[indiceAuxiliar].recorrencia);
}
printf("Eventos gravados com sucesso! \n");
fclose(arq1);
} else {
printf("ATENÇÃO! Não é possível abrir o arquivo %s para escrita.\n", nomeDoArquivo);
}
break;
case 4:
printf("\n----------------------------------------");
printf("----------------------------------------\n");
printf("Etapa Dois - Manipulação de Arquivos\n");
printf("1 - Interação direta com o usuário.\n");
printf("2 - Leitura e escrita em arquivo.\n");
printf("Escolha uma opção... \n");
opcaoA = lerNumero();
switch (opcaoA) {
case 1:
printf("Digite uma frase: ");
lerLinha(linha);
printf("A frase é: %s\n", linha);
break;
case 2:
printf("Informe o nome completo do arquivo: ");
lerLinha(nomeDoArquivo);
arq1 = fopen(nomeDoArquivo, "r");
if (arq1) {
printf("\nA seguir, o seu conteúdo original: \n");
printf("--- Início do arquivo %s ---\n", nomeDoArquivo);
indice = 0;
do {
//fscanf(arq1, "%s\n",eventos[indice].titulo);
fscanf(arq1, "%s\n",linhaa);
auxiliar = strrchr(linhaa,':');
strcpy(eventos[indice].titulo, auxiliar+2);
printf("%s\n",eventos[indice].titulo);
fscanf(arq1, "%s\n",linhaa);
auxiliar = strrchr(linhaa,':');
strcpy(eventos[indice].dataDeInicio, auxiliar+2);
printf("%s\n",eventos[indice].dataDeInicio);
fscanf(arq1, "%s\n",linhaa);
auxiliar = strrchr(linhaa,':');
strcpy(eventos[indice].dataDeCriacao, auxiliar+2);
printf("%s\n",eventos[indice].dataDeCriacao);
fscanf(arq1, "%s\n",linhaa);
auxiliar = strrchr(linhaa,':');
strcpy(eventos[indice].dataDeFim, auxiliar+2);
printf("%s\n",eventos[indice].dataDeFim);
fscanf(arq1, "%s\n",linhaa);
auxiliar = strrchr(linhaa,':');
strcpy(eventos[indice].horarioDeInicio, auxiliar+2);
printf("%s\n",eventos[indice].horarioDeInicio);
fscanf(arq1, "%s\n",linhaa);
auxiliar = strrchr(linhaa,':');
strcpy(eventos[indice].horarioDeCriacao, auxiliar+2);
printf("%s\n",eventos[indice].horarioDeCriacao);
fscanf(arq1, "%s\n",linhaa);
auxiliar = strrchr(linhaa,':');
strcpy(eventos[indice].horarioDeFim, auxiliar+2);
printf("%s\n",eventos[indice].horarioDeFim);
fscanf(arq1, "%s\n",linhaa);
auxiliar = strrchr(linhaa,':');
strcpy(eventos[indice].local, auxiliar+2);
printf("%s\n",eventos[indice].local);
fscanf(arq1, "%s\n",linhaa);
auxiliar = strrchr(linhaa,':');
strcpy(eventos[indice].estado, auxiliar+2);
printf("%s\n",eventos[indice].estado);
fscanf(arq1, "%s\n",linhaa);
auxiliar = strrchr(linhaa,':');
strcpy(eventos[indice].categoria, auxiliar+2);
printf("%s\n",eventos[indice].categoria);
fscanf(arq1, "%s\n",linhaa);
auxiliar = strrchr(linhaa,':');
strcpy(eventos[indice].recorrencia, auxiliar+2);
printf("%s\n",eventos[indice].recorrencia);
indice = indice + 1;
} while (!feof(arq1));
printf("--- Fim do arquivo %s ---\n", nomeDoArquivo);
fclose(arq1);
} else {
printf("ATENÇÃO! Não é possível abrir o arquivo %s para leitura.\n", nomeDoArquivo);
}
break;
case 3:
printf("Fim do programa.\n");
break;
default:
printf("Digite um número entre 1 e 5, por favor.\n");
while (opcaoA != 3);
}
case 5:
printf("programa finalizado. \n");
}
}
} while (opcao != 5);
}
Camila e Claudinei
/* ... */
{
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);
}
Celio
// 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);
}
Danti e Juan
#include <stdio.h>
#include <time.h>
#include <string.h>
//Struct de data e hora do computador------------------------------------------------------
//Uma estrutura (struct) é uma coleção de campos que podem ser referenciados pelo mesmo nome. A estrutura permite que
//informações relacionadas mantenham-se juntas.
//A declaração de uma estrututa define um tipo de dado, ou seja, informa ao computador o número de bytes que será
//necessáiro reservar para uma variável que venha a ser declarada como sendo desse tipo.
struct Data {
int ano, mes, dia;
int hora, minuto;
};
//tipo de dado time_t é definido pela biblioteca ISO da linguagem C para armazenar valores de tempo. Estes valores são
//obtidos através da função time() que é definida no arquivo de cabeçalho de nome <time.h>. O padrão ISO C define o
//time_t como um tipo aritmético, mas não especifica qualquer tipo de dado, intervalo de valores, freqüência ou
//codificação para ele. O resultado das operações aritméticas sobre este tipo também não são determinadas por este
//padrão.
struct Data agora() {
struct Data now;
struct tm* systemTime;
time_t timestamp;
timestamp = time(NULL);
systemTime = localtime(×tamp);
now.dia = systemTime->tm_mday;
now.mes = systemTime->tm_mon + 1;
now.ano = systemTime->tm_year + 1900;
now.hora = systemTime->tm_hour;
now.minuto = systemTime->tm_min;
return now;
};
//para mostrar a data e hora do computador----------------------------------------
//void função que não retorna valores--------------------------------------------------
void mostra_data(struct Data d) {
printf("%02d/%02d/%04d ás %02d:%02d\n\n", d.dia, d.mes, d.ano, d.hora, d.minuto);
};
//Struct de data e horario-------------------------------------------------------------------
//struct DataHorario {
//int dia, mes, ano;
//int hora, minuto;
//};
//Para mostrar a data e a hora-----------------------------------------------------------
//void mostra_data(struct DataHorario umaData) {
//printf("%d/%d/%d %d:%d:%d", umaData.dia, umaData.mes, umaData.ano, umaData.hora, umaData.minuto);
//}
//Eventos----------------------------------------------------------------------------
struct evento{
char titulo[32];
char local[32];
char data[32];
char horario[32];
char tipo[32];
char descricao[128];
char sair[10];
};
//Esse é um teste para quando alguém for digitar uma letra na hora de escolher opção.
//Em vez de usar o scanf usar meu_scanf.
int meu_scanf(char * menu) {
int x, n;
do {
//printf(menu);
n = scanf("%d", &x);
if (n == 0) {
n = scanf("%*[^\n]");
}
} while (n == 0);
return x;
} //Aqui termina o teste.------------------------------------------------------------------
// uma linha inteira até o usuário digitar <ENTER>
void lerLinha(char* linha)
{
scanf(" %[^\n]", linha);
}
//INICIO DO PROGRAMA!!!!-------------------------------------------------------------------
int main () {//COMEÇO DAS CHAVES DO INT MAIN
int opcao=0;
int indice=0;
struct Data umaData;
struct evento Evento[50];
FILE *arq1;
char nomeDoArquivo[100];
char *leu;
char arquivo[100];
char Titulo[100];
//MENU PRINCIPAL-------------------------------------------------------------------------------
//WHILE MENU PRINCIPAL-------------------------------------------------------------------------
while (opcao != 7){
printf("\n ////Danti////Juan ////copyright 2009////");
printf("\n __________________ _____________________");
printf("\n| |");
printf("\n| |");
printf("\n| BEM VINDO: AGENDA v1.0 |");
printf("\n| |");
printf("\n| |");
printf("\n|_______________________________________|");
printf("\n ////Danti////Juan///copyright 2009////\n");
printf("\n\nVocê está em -------------MENU PRINCIPAL!\n\n");
printf("1.Visualizar uma Agenda Salva.\n");
printf("2.Criar e Editar uma Agenda.\n");
printf("3.Salvar da Memória em um Arquivo.\n");
printf("4.Visualizar seus Eventos Criados até Agora.\n");
printf("7.Sair.\n");
opcao = meu_scanf("Escolha uma opção: ");
//opções:
//relação salvar em arquivo
switch (opcao){
case 1:
puts ("\nVocê está em -------------1.Visualizar uma Agenda Salva!\n");
printf("Digite seu nome: ");
lerLinha(nomeDoArquivo);
arq1 = fopen(nomeDoArquivo, "r");
if(arq1)
{
printf("\nA seguir, o seu conteúdo original: \n");
printf("--- Início do arquivo %s ---\n", nomeDoArquivo);
do
{
leu = fgets(arquivo, sizeof(arquivo), arq1);
if (leu)
{
printf("%s", arquivo);
}
} while (! feof(arq1));
printf("\n--- Fim do arquivo %s ---\n", nomeDoArquivo);
fclose(arq1);
}
else
{
printf("ATENÇÃO! Não é possível abrir o arquivo");
printf(" %s para escrita.\n", nomeDoArquivo);
}
break;
case 2:
puts("\n2.Criar e Editar uma Agenda!!\n");
printf ("\nINSIRA UM EVENTO: %d", indice +1);
//TITULO
printf("\nTitulo: ");
lerLinha(Evento[indice].titulo);
//LOCAL
printf("Local: ");
lerLinha(Evento[indice].local);
printf("Data: ");
lerLinha(Evento[indice].data);
printf("Horario: ");
lerLinha(Evento[indice].data);
printf("Tipo de evento: ");
lerLinha(Evento[indice].tipo);
printf("Descrição: ");
lerLinha(Evento[indice].descricao); //o 127 é para limitar o tamanho da descrição e tem q ter o valor - 1
//que é a quebra de linha final e o resto eh para ignorar os caracteres especiais menos o /n (quebra de linha)
//e ainda o espaço na frente do % é pra ele ignorar o caracter anterior que eh quebra de linha.
printf("Evento criado em: ");
umaData = agora();
mostra_data(umaData);
indice = indice + 1;
break;
case 3:
puts("\n3.Salvar da Memória em um Arquivo!!!\n");
printf("\nInforme o seu nome: ");
lerLinha(nomeDoArquivo);
arq1 = fopen(nomeDoArquivo, "w");//abrindo arquivo e salvar!!!!!
if(arq1)//SE ARQ1
{
printf("\nSalvando...........................\n");
printf("\nSalvando...........................\n");
printf("\nSalvando...........................\n");
printf("\nSalvando...........................\n");
// Evento[indice].titulo = Titulo;
fprintf(arq1," %s ", Titulo);
printf("\nSucesso!!!!!!!!!!!!!!!!!!!!!\n");
fclose(arq1);//fechando arquivo!!!!!
}
else//ENTÃO ARQ1 (SE)
{
printf("ATENÇÃO! Não é possível abrir o arquivo %s para escrita.\n", nomeDoArquivo);
}
break;
case 4:
puts("\n4.Visualizar seus Eventos Criados até Agora!!!!\n");
if(indice == 0)//SE INDICE = (IGUAL) DE 0: SEM EVENTOS CADASTRADOS-----------------------------------------
{
printf("\nNão há eventos cadastrados.\n");
printf("\nNão há eventos cadastrados.\n");
}
else//ENTÃO =! (DIFERENTE) DE 0: REGISTRAR EVENTOS NA MEMÓRIA SEM SALVAR EM ARQUIVO NO HD--------
{
printf("Foi(foram) Criado(s) %d evento(s).\n", indice);//%d VARIAÇÃO DE EVENTOS, EM VAR INDICE-
printf("Selecione um evento entre 0 - %d: \n",indice-1);
opcao = meu_scanf("Escolha uma opção: ");
if (opcao < 0 || opcao > indice)// SE OPÇÃO MENOR QUE ZERO E OPÇÃO MAIOR QUE----
{//INDICE -> MOSTRA FORA DOS LIMITES 50-----------------------------------------
printf("Passou o limite de 50 eventos.\n");
}
else//ENTÃO MOSTRAR
{
printf("Titulo: %s\n",Evento[opcao].titulo);
printf("Local: %s\n", Evento[opcao].local);
printf("Data: %s\n", Evento[opcao].data);
printf("Horario: %s\n", Evento[opcao].horario);
printf("Tipo: %s\n", Evento[opcao].tipo);
printf("Descrição: %s\n", Evento[opcao].descricao);
}
}
break;
//CASE7: ESCOLHENDO DO MENU PRINCIPAL------------------------------------------------------------------
//CASE7: SAIR DO PROGRAMA------------------------------------------------------------------------------
case 7:
puts ("\ntchau!tchau!tchau!tchau!tchau!tchau!tchau!tchau!tchau!tchau!\n");
break;
default:
puts ("\nOpção desconhecida!");
break;
} //!!!!!!!!!!!!!!!!!FIM DO SWITCH DO MENU PRINCIPAL-----------------------------------------
} //FIM DO WHILE MENU PRINCIPAL--------------------------------------------------------------
} //FIM DAS CHAVES DO INT MAIN ENTÃO É O FIM-------------------------------------------------
//Fim do programa----------------------------------------------------------------------------
Nathan e Thayse
#include <stdio.h>
#include <time.h>
struct evento
{
char titulo[50];
char dataDeInicio[11];
char horarioDeInicio[6];
char dataDeTermino[11];
char horarioDeTermino[6];
char dataDeCriacao[11];
char horarioDeCriacao[6];
char descricao[100];
char local[100];
char estado[20];
char categoria[10];
char recorrencia[20];
};
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);
}
char* hora_minuto(char * data) {
time_t agora;
struct tm ts;
agora = time(NULL);
ts = *localtime(&agora);
strftime(data, 6, "%H:%M", &ts);
}
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;
}
void lerLinha(char* linha)
{
scanf(" %[^\n]", linha);
}
int main()
{
int opcao;
int indice = 0;
struct evento eventos[100];
do
{
printf("\n\nOpção 1: criar um evento.\n");
printf("Opção 2: mostrar 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:
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);
hora_minuto(eventos[indice].horarioDeCriacao);
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;
#include <stdio.h>
int main();
{
FILE *arquivo;
arquivo = fopen("C:arquivo.txt", "w");
fprintf(arquivo, "Novo arquivo texto criado em C!");
fclose(arquivo);
return 1;
}
break;
case 2:
#include <stdio.h>
int main(); {
FILE *arquivo;
int i;
char nome[100];
arquivo = fopen("C:arquivo.txt", "r");
i = 0;
while(feof(arquivo) == 0) {
nome[i] = getc(arquivo);
i ++;
}
fclose(arquivo);
printf("%s", nome);
return 1;
}
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;
case 3:
printf("Fim do programa. Adeus!\n");
break;
default:
printf("Por favor, escolha um número entre 1 e 3.\n");
}
} while (opcao != 3);
}
Thiago Felipe
#include <stdio.h>
#include <string.h>
#include <time.h>
// estrutura eventos
struct eventoNovo {
char titulo[64];
char dataInicio[11];
char horarioInicio[6];
char dataTermino[11];
char horarioTermino[6];
char dataCriacao[11];
char horarioCriacao[6];
char descricao[1024];
char local[64];
char estado[32];
char categoria[32]; //Trabalho, estudo, pessoal
char recorrencia[32];
char recorrencia2[5];
int visivel;
};
char data[100];
char * string;
//data atual
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);
}
char* hora_minuto(char * data) {
time_t agora;
struct tm ts;
agora = time(NULL);
ts = *localtime(&agora);
strftime(data, 6, "%H:%M", &ts);
}
//ler numero
int lerNumero(){
int numero;
int leuNumero = 1;
do {
if (leuNumero == 0) {
printf("\nErro ao ler opção, Digite-a novamente: ");
}
leuNumero = scanf("%d", &numero);
if (leuNumero == 0) {
leuNumero = scanf("%*[^\n]");
}
}
while (leuNumero == 0);
return numero;
}
// ler linha
void lerLinha(char * linha) {
scanf(" %[^\n]", linha);
}
// formatar data
char formatarData(){
string = strtok (data," /,-");
int cont3=2;
char dia[4];
char mes[4];
char ano[6];
while (string != NULL) {
if(cont3 == 2) {
strcpy(dia, string);
}else{
if(cont3 == 1) {
strcpy(mes, string);
}else{
strcpy(ano, string);
}
}
string = strtok (NULL, " /,-");
cont3--;
}
strcpy(data, ano);
strcat(data, mes);
strcat(data, dia);
return data;
}
int main(int argc, char ** argv) {
//variaveis
int op=0;
int indice=0;
FILE *arq1;
char nomeDoArquivo[100];
char linha[500];
char *leu;
int cont=0;
int numero=0;
int real[100];
struct eventoNovo eventos[100];
char nada=0;
int op2;
int opcao;
//
printf("\nInforme o seu nome: ");
lerLinha(nomeDoArquivo);
arq1 = fopen(nomeDoArquivo, "r");
if(arq1) {
printf("Arquivo carregado corretamente..\n");
}else {
printf("\nNão foi possivel abrir sua agenda.\nEscolha a opção 5 no menu principal para salvar seus compromissos em um arquivo.\n\n", nomeDoArquivo);
}
while(op != 7) {
printf("\n\nO que você deseja fazer?\n");
printf("\n 1 - Ver agenda");
printf("\n 2 - Adicionar Evento");
printf("\n 3 - Alterar evento");
printf("\n 4 - Excluir Evento");
printf("\n 5 - Salvar no formato ICal");
printf("\n 6 - Excluir Agenda");
printf("\n 7 - Sair da Agenda");
printf("\n Opção: ");
op=lerNumero();
printf("\n");
switch (op) {
//ver
case 1 :
if(indice == 0) {
printf("Não há eventos cadastrados.\n");
break;
}else{
if(indice==1){
printf("\n\nExiste 1 evento cadastrado.\n\n");
numero=1;
printf("1 - %s %s - %s\n", eventos[numero].dataInicio, eventos[numero].horarioInicio, eventos[numero].titulo);
real[numero]=1;
}else{
printf("\n\nQual evento você deseja ver?\n\n");
numero=0;
for(cont=0;cont<=indice;cont++) {
if(eventos[cont].visivel == 1) {
numero++;
real[numero]=cont;
printf("%i - %s %s - %s\n", numero, eventos[cont].dataInicio, eventos[cont].horarioInicio, eventos[cont].titulo);
}
}
}
}
if(numero==1) {
printf("\nDigite 1 para ver o evento: ");
}else{
printf("\nEscolha uma opção entre 1 e %i: ", numero);
}
op = lerNumero();
if (op < 0 || op > numero) {
printf("Número fora dos limites.\n");
}else {
printf("\nSobre o evento:\n\n");
printf("Título: %s\n", eventos[real[op]].titulo);
printf("Data de início: %s\n", eventos[real[op]].dataInicio);
printf("Hora de início: %s\n", eventos[real[op]].horarioInicio);
printf("Data de término: %s\n", eventos[real[op]].dataTermino);
printf("Hora de término: %s\n", eventos[real[op]].horarioTermino);
printf("Data de criação: %s\n", eventos[real[op]].dataCriacao);
printf("Hora de criação: %s\n", eventos[real[op]].horarioCriacao);
printf("Descrição: %s\n", eventos[real[op]].descricao);
printf("Local de realização: %s\n", eventos[real[op]].local);
printf("Estado: %s\n", eventos[real[op]].estado);
printf("Categoria: %s\n", eventos[real[op]].categoria);
printf("Recorrência: %s\n", eventos[real[op]].recorrencia);
}
break;
//adicionar
case 2 :
indice++;
printf("Título: ");
lerLinha(eventos[indice].titulo);
printf("Data de Início(dd/mm/aaaa): ");
lerLinha(eventos[indice].dataInicio);
printf("Horário de Início(hh:mm): ");
lerLinha(eventos[indice].horarioInicio);
printf("Data de término(dd/mm/aaaa): ");
lerLinha(eventos[indice].dataTermino);
printf("Horário de Término(hh:mm): ");
lerLinha(eventos[indice].horarioTermino);
dia_mes_ano(eventos[indice].dataCriacao);
hora_minuto(eventos[indice].horarioCriacao);
printf("Descrição: ");
lerLinha(eventos[indice].descricao);
printf("Local : ");
lerLinha(eventos[indice].local);
printf("Estado: ");
lerLinha(eventos[indice].estado);
printf("Categoria: ");
lerLinha(eventos[indice].categoria);
printf("Recorrência: ");
printf("\n\t 1 - Anual\n\t 2 - Mensal\n\t 3 - Semanal\n\t 4 - Diario\n\t 5 - Não Possui\n\t Opção: ");
int valida=0;
while (valida != 1) {
op2=lerNumero();
switch (op2) {
case 1 :
strcpy(eventos[indice].recorrencia,"Anual");
strcpy(eventos[indice].recorrencia2,"1");
valida=1;
break;
case 2 :
strcpy(eventos[indice].recorrencia,"Mensal");
strcpy(eventos[indice].recorrencia2,"2");
valida=1;
break;
case 3 :
strcpy(eventos[indice].recorrencia,"Semanal");
strcpy(eventos[indice].recorrencia2,"3");
valida=1;
break;
case 4 :
strcpy(eventos[indice].recorrencia,"Diario");
strcpy(eventos[indice].recorrencia2,"4");
valida=1;
break;
case 5 :
strcpy(eventos[indice].recorrencia,"Não");
strcpy(eventos[indice].recorrencia2,"5");
valida=1;
break;
default :
printf("Opção Invalida!\n\t Digite novamente sua Opção: ");
break;
}
}
eventos[indice].visivel=1;
break;
//alterar
case 3 :
if(indice == 0) {
printf("Não há eventos cadastrados.\n");
break;
}else{
printf("Qual evento você deseja alterar?\n\n");
numero=0;
for(cont=0;cont<=indice;cont++) {
if(eventos[cont].visivel == 1) {
numero++;
real[numero]=cont;
printf("%i - %s %s - %s\n", numero, eventos[cont].dataInicio, eventos[cont].horarioInicio, eventos[cont].titulo);
}
}
}
printf("Escolha um evento entre 1 e %d: ",numero);
op2 = lerNumero();
while(op != 12) {
printf("\nO que você deseja alterar?\n\n");
printf("1 - Título\n");
printf("2 - Data de Início\n");
printf("3 - Horário de Início\n");
printf("4 - Data de término\n");
printf("5 - Horário de Término\n");
printf("6 - Descrição\n");
printf("7 - Local\n");
printf("8 - Estado\n");
printf("9 - Categoria\n");
printf("10 - Recorrência\n");
printf("11 - Tudo\n");
printf("12 - Voltar Menu Principal\n");
printf("Opção: ");
op = lerNumero();
if (op < 1 || op > 12){
printf("\nOpção Inválida. Tente uma opção entre 1 e 12.\n\n");
}else{
switch (op) {
case 1 :
printf("Novo titulo: ");
lerLinha(eventos[real[op2]].titulo);
break;
case 2 :
printf("Nova Data de Início(dd/mm/aaaa): ");
lerLinha(eventos[real[op2]].dataInicio);
break;
case 3 :
printf("Novo Horário de Início(hh:mm): ");
lerLinha(eventos[real[op2]].horarioInicio);
break;
case 4 :
printf("Nova Data de término(dd/mm/aaaa): ");
lerLinha(eventos[real[op2]].dataTermino);
break;
case 5 :
printf("Novo Horário de Término(hh:mm): ");
lerLinha(eventos[real[op2]].horarioTermino);
break;
case 6 :
printf("Nova Descrição: ");
lerLinha(eventos[real[op2]].descricao);
break;
case 7 :
printf("Novo Local : ");
lerLinha(eventos[real[op2]].local);
break;
case 8 :
printf("Novo Estado: ");
lerLinha(eventos[real[op2]].estado);
break;
case 9 :
printf("Nova Categoria: ");
lerLinha(eventos[real[op2]].categoria);
break;
case 10 :
printf("Nova Recorrência: ");
printf("\n\t 1 - Anual\n\t 2 - Mensal\n\t 3 - Semanal\n\t 4 - Diario\n\t 5 - Não Possui\n\t Opção: ");
int valida = 0;
while (valida != 1) {
op=lerNumero();
switch (op) {
case 1 :
strcpy(eventos[real[op2]].recorrencia,"Anual");
strcpy(eventos[indice].recorrencia2,"1");
valida=1;
break;
case 2 :
strcpy(eventos[real[op2]].recorrencia,"Mensal");
strcpy(eventos[indice].recorrencia2,"2");
valida=1;
break;
case 3 :
strcpy(eventos[real[op2]].recorrencia,"Semanal");
strcpy(eventos[indice].recorrencia2,"3");
valida=1;
break;
case 4 :
strcpy(eventos[real[op2]].recorrencia,"Diario");
strcpy(eventos[indice].recorrencia2,"4");
valida=1;
break;
case 5 :
strcpy(eventos[real[op2]].recorrencia,"Não");
strcpy(eventos[indice].recorrencia2,"5");
valida=1;
break;
default :
printf("Opção Invalida!");
break;
}
}
break;
case 11 :
printf("Título: ");
lerLinha(eventos[real[op2]].titulo);
printf("Data de Início(dd/mm/aaaa): ");
lerLinha(eventos[real[op2]].dataInicio);
printf("Horário de Início(hh:mm): ");
lerLinha(eventos[real[op2]].horarioInicio);
printf("Data de término(dd/mm/aaaa): ");
lerLinha(eventos[real[op2]].dataTermino);
printf("Horário de Término(hh:mm): ");
lerLinha(eventos[real[op2]].horarioTermino);
dia_mes_ano(eventos[real[op2]].dataCriacao);
hora_minuto(eventos[real[op2]].horarioCriacao);
printf("Descrição: ");
lerLinha(eventos[real[op2]].descricao);
printf("Local : ");
lerLinha(eventos[real[op2]].local);
printf("Estado: ");
lerLinha(eventos[real[op2]].estado);
printf("Categoria: ");
lerLinha(eventos[real[op2]].categoria);
printf("Recorrência: ");
printf("\n\t 1 - Anual\n\t 2 - Mensal\n\t 3 - Semanal\n\t 4 - Diario\n\t 5 - Não Possui\n\t Opção: ");
valida = 0;
while (valida != 1) {
op=lerNumero();
switch (op) {
case 1 :
strcpy(eventos[real[op2]].recorrencia,"Anual");
strcpy(eventos[indice].recorrencia2,"1");
valida=1;
break;
case 2 :
strcpy(eventos[real[op2]].recorrencia,"Mensal");
strcpy(eventos[indice].recorrencia2,"2");
valida=1;
break;
case 3 :
strcpy(eventos[real[op2]].recorrencia,"Semanal");
strcpy(eventos[indice].recorrencia2,"3");
valida=1;
break;
case 4 :
strcpy(eventos[real[op2]].recorrencia,"Diario");
strcpy(eventos[indice].recorrencia2,"4");
valida=1;
break;
case 5 :
strcpy(eventos[real[op2]].recorrencia,"Não");
strcpy(eventos[indice].recorrencia2,"5");
valida=1;
break;
default :
printf("Opção Invalida!");
break;
}
}
op=12;
break;
case 12 :
break;
default :
printf("Opção invalida!\n Tente uma opção entre 1 e 12");
break;
}
}
}
break;
//excluir evento
case 4 :
if(indice == 0) {
printf("Não há eventos cadastrados.\n");
break;
}else{
printf("Qual evento você deseja excluir?\n\n");
numero=0;
for(cont=1;cont<=indice;cont++) {
if(eventos[cont].visivel == 1) {
numero++;
real[numero]=cont;
printf("%i - %s %s - %s\n", numero, eventos[cont].dataInicio, eventos[cont].horarioInicio, eventos[cont].titulo);
}
}
}
printf("Escolha um evento entre 1 e %i: ",numero);
op = lerNumero();
if(op<1 || op>numero) {
printf("\nOpção invalida!\n");
}else{
eventos[real[op]].visivel=0;
}
printf("Evento excluido com Sucesso");
break;
//salvar ical
case 5 :
printf("\n\nInforme o nome completo do arquivo: ");
lerLinha(nomeDoArquivo);
arq1 = fopen(nomeDoArquivo, "w");
if(arq1) {
printf("\nATENÇÂO, já existe um arquivo com esse nome!\n");
printf("Deseja mudar o seu conteúdo?\n");
}else {
printf("O arquivo %s não existe.\n", nomeDoArquivo);
printf("Deseja criá-lo?\n");
}
printf("1 - Sim\n");
printf("2 - Não\n");
printf("Digite a sua opção: ");
op = lerNumero();
switch(op) {
case 1:
if(arq1) {
fprintf(arq1,"BEGIN:VCALENDAR\n\n\n");
for(cont=0;cont<=indice;cont++) {
if(eventos[cont].visivel == 1) {
/*string = strtok(datainicio,'/,:');
datainicio = strtok (NULL, "/");
printf("%s", datainicio);*/
/*char dataInicio[100];
strcpy(dataInicio, eventos[cont].dataInicio);
string = strtok (dataInicio," /,-");
int cont3=2;
char dia[4];
char mes[4];
char ano[6];
while (string != NULL) {
printf ("%s\n",string);
if(cont3 == 2) {
strcpy(dia, string);
}else{
if(cont3 == 1) {
strcpy(mes, string);
}else{
strcpy(ano, string);
}
}
string = strtok (NULL, " /,-");
cont3--;
}
strcpy(dataInicio, ano);
strcat(dataInicio, mes);
strcat(dataInicio, dia);*/
/*op2=eventos[cont].recorrencia2;
switch (op2) {
case 1 :
tipo = "RRULE:FREQ=YEARLY;WKST=SU";
break;
case 2 :
tipo = "RRULE:FREQ=MONTHLY;WKST=SU;BYMONTHDAY=30";
break;
case 3 :
tipo = "RRULE:FREQ=WEEKLY;WKST=SU";
break;
case 4 :
tipo = "RRULE:FREQ=DAILY;WKST=SU";
break;
case 5 :
tipo = "";
break;
} */
strcpy(data, eventos[cont].dataInicio);
formatarData();
printf("%s", data);
fprintf(arq1,"BEGIN:VEVENT\nDTSTART:%sT%s00Z\nDTEND:%sT%s00Z\nCLASS:%s\nCREATED:%sT%s00Z\nDESCRIPTION:%s\nLAST-MODIFIED:%sT%s00Z\nLOCATION:%s\nRRULE:%s\nSTATUS:%s\nSUMMARY:%s\nTRANSP:OPAQUE\nEND:VEVENT\nEOF", data, eventos[cont].horarioInicio, eventos[cont].dataTermino, eventos[cont].horarioTermino, eventos[cont].categoria, eventos[cont].dataCriacao, eventos[cont].horarioCriacao, eventos[cont].descricao, eventos[cont].dataCriacao, eventos[cont].horarioCriacao, eventos[cont].local, eventos[cont].recorrencia, eventos[cont].estado, eventos[cont].titulo);
}
}
fprintf(arq1,"\nEND:VCALENDAR");
fclose(arq1);
}else{
printf("ATENÇÃO! Não é possível abrir o arquivo %s para escrita.\n", nomeDoArquivo);
}
break;
case 2:
printf("Conteúdo original não alterado...\n");
break;
default:
printf("Opção inválida.\n");
break;
}
break;
//excluir agenda
case 6 :
printf("excluir agenda");
break;
//sair
case 7 :
printf("O que que é o estudo, bixo!");
break;
default :
printf("Opção invalida!\n Tente uma opção entre 1 e 7");
break;
}
printf("\n");
}
return 0;
}
Código Genérico
#include <stdio.h>
#include <time.h>
struct evento
{
char titulo[50];
char dataDeInicio[10];
char horarioDeInicio[5];
char dataDeTermino[10];
char horarioDeTermino[5];
char dataDeCriacao[11];
char horarioDeCriacao[6];
char descricao[100];
char local[100];
char estado[20];
char categoria[10];
char recorrencia[20];
};
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);
}
char* hora_minuto(char * data)
{
time_t agora;
struct tm ts;
agora = time(NULL);
ts = *localtime(&agora);
strftime(data, 6, "%H:%M", &ts);
}
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;
}
void lerLinha(char* linha)
{
scanf(" %[^\n]", linha);
}
int main()
{
int opcao;
int indice = 0;
struct evento eventos[100];
FILE *arq1;
char nomeDoArquivo[255];
do
{
printf("\n\nOpção 1: criar um evento.\n");
printf("Opção 2: mostrar um evento já criado.\n");
printf("Opção 3: gravar todos os eventos em arquivo.\n");
printf("Opção 4: Sair do programa.\n");
printf("Digite a sua opção: ")
opcao = lerNumero();
switch{opcao}
{
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[imdice].dataDeCriacao);
hora_minuto(eventos[indice].horarioDeCriacao);
print("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;
break;
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].horaDeCriacao);
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;
case 3:
printf("Digite o nome do arquivo: ");
lerLinha(nomeDoArquivo);
if(arquivo = fopen(nomeDoArquivo, "w"))
{
int contadorAuxiliar;
for(contadorAuxiliar = 0; contadorAuxiliar < indice; contadorAuxiliar++)
{
fputs(eventos[contadorAuxiliar].titulo,arquivo);
fprintf(arquivo, "\n");
fputs(eventos[contadorAuxiliar].dataDeInicio,arquivo);
fprintf(arquivo, "\n");
fputs(eventos[contadorAuxiliar].horarioDeInicio,arquivo);
fprintf(arquivo, "\n");
fputs(eventos[contadorAuxiliar].dataDeTermino,arquivo);
fprintf(arquivo, "\n");
fputs(eventos[contadorAuxiliar].horarioDeTermino,arquivo);
fprintf(arquivo, "\n");
fputs(eventos[contadorAuxiliar].dataDeCriacao,arquivo);
fprintf(arquivo, "\n");
fputs(eventos[contadorAuxiliar].horarioDeCriacao,arquivo);
fprintf(arquivo, "\n");
fputs(eventos[contadorAuxiliar].descricao,arquivo);
fprintf(arquivo, "\n");
fputs(eventos[contadorAuxiliar].local,arquivo);
fprintf(arquivo, "\n");
fputs(eventos[contadorAuxiliar].estado,arquivo);
fprintf(arquivo, "\n");
fputs(eventos[contadorAuxiliar].categoria,arquivo);
fprintf(arquivo, "\n");
fputs(eventos[contadorAuxiliar].recorrencia,arquivo);
fprintf(arquivo, "\n");
}
printf("\nArquivo gravado com sucesso: %s.\n", nomeDoArquivo);
fclose(arquivo);
}
else
{
printf("Não foi possível abrir o arquivo %s para escrita.\n",
nomeDoArquivo);
return -1;
}
break;
case 4:
printf("Fim do programa. Adeus!\n");
break;
default:
printf("Por favor, escolha um número entre 1 e 4.\n");
}
} while (opcao != 4);
}