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);
}
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
#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