PROGRAMAÇÃO DE MICROPROCESSADORES 2007 / 2008

Transcrição

1 Departamento de Engenharia Electrotécnica PROGRAMAÇÃO DE MICROPROCESSADORES 2007 / 2008 Mestrado Integrado em Engenharia Electrotécnica e Computadores 1º ano 1º semestre Ficheiros e estruturas Luis Bernardo e Paulo Pinto

2 1 Introdução Nos capítulos 10 e 11 do livro Linguagem C de Luís Damas, recomendado para a disciplina de Programação de Microprocessadores, é feita a apresentação dos ficheiros e das estruturas. Esta aula visa consolidar estas matérias através de um conjunto de exercícios. Durante a aula vai ser desenvolvida em várias fases uma aplicação que mantém um ficheiro em modo binário com dados de alunos. As primeiras fases têm como objectivo complementar o estudo realizado na aula teórica. A última fase, que corresponde ao programa completo, é avaliada pelo docente. GUARDE O CÓDIGO desenvolvido na memória USB. Durante a aula seguinte o docente pode pedir-lhe para mostrar o código desenvolvido, e pode fazer-lhe algumas perguntas. O método de trabalho é semelhante ao das aulas anteriores: nas primeiras fases edita-se o ficheiro fonte alunos.c com o código fornecido junto do enunciado, e realizam-se as modificações pedidas. Na última fase o objectivo é resolver o problema proposto, aplicando os conceitos aprendidos nesta secção da matéria. 2 Exercícios de aprendizagem Pretende-se desenvolver uma aplicação que permite gerir um ficheiro com o nome, número e turno dos alunos de uma disciplina. A aplicação recebe o nome do ficheiro a partir de um argumento da linha de comando, parando caso o utilizador não introduza esse parâmetro. Depois, oferece um menu com as opções de acrescentar aluno, apagar aluno, listar alunos, e apagar todos os alunos. Este trabalho vai ser usado para aprender a trabalhar com estruturas e com ficheiros. Os dados são guardados no ficheiro em formato binário, e são acedidos no programa através de uma estrutura. Claro que o trabalho usa tudo o que foi aprendido nas aulas anteriores. 2.1 ESTRUTURAS DE DADOS O primeiro aspecto relevante é definir como se vão manipular os dados relativos a cada um dos alunos na memória do computador. As estruturas oferecem a maneira ideal para manipular um conjunto de campos inter-relacionados como uma variável única. Neste trabalho vai usar-se a estrutura struct Aluno para guardar os dados de cada aluno, e para ler e escrever no ficheiro. Define-se ainda o tipo bool (Booleano) como sendo igual a int, como exemplo de definição de um tipo novo. typedef int bool; #define TRUE 1 #define FALSE 0 #define MAX_STUDENTNAME_LENGTH 160 struct Aluno { char nome[max_studentname_length]; int numero; int turno; ; 2

3 Repare que com esta estrutura é possível ter uma variável que tem os três campos simultaneamente para se seleccionar um campo usa-se o ponto (. ) ou a seta ( -> ) respectivamente para uma variável ou para um apontador. Por exemplo: struct Aluno aluno; struct Aluno *aluno_ptr= &aluno; aluno.numero= 1; /* Usa o ponto "." */ strcpy(aluno_ptr->nome, "Paulo"); /* Usa a seta "->" */ 2.2 EXERCÍCIO DE APRENDIZAGEM: VERSÃO 1 DA APLICAÇÃO Tal como nos dois enunciados anteriores, neste trabalho são fornecidas várias funções que realizam no conjunto a aplicação pretendida: um sistema para manter uma lista de alunos. O PRIMEIRO EXERCÍCIO É CRIAR UM FICHEIRO alunos.c, e COPIAR TODAS AS FUNÇÕES FORNECIDAS NO ENUNCIADO PARA ESSE FICHEIRO. Não se esqueça que, tal como nos trabalhos anteriores, não deve colocar funções dentro de funções, e deve declarar uma função, ou um protótipo da função, antes de invocar a função no código. Vai desenvolver-se a aplicação a partir da função main. Neste trabalho, a função main está estruturada como um menu, que apresenta a lista de opções e em seguida corre uma função associada à opção escolhida. Este trabalho também tem a novidade de receber o nome do ficheiro pela linha de comando. Assim, a aplicação deve ser chamada com um parâmetro (por exemplo./alunos dados.dat ). Repare que a função main tem dois parâmetros: argc tem o número de palavras na linha de comando (2 no exemplo); argv tem um array de strings com cada uma das palavras (no exemplo, argv[0]== alunos e argv[1]== dados.dat ). Caso o utilizador não introduza o parâmetro, a aplicação termina com uma mensagem de erro. O programa fica no menu principal até que o utilizador introduza a opção 0 Sair. #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> main(int argc, char *argv[]) { int opcao; printf("%s - Programa de gestão de alunos\n", argv[0]); if (argc!= 2) { printf(" Erro na invocação do programa\n"); printf(" Use %s nome_do_ficheiro\n", argv[0]); exit(1); do { /* CICLO PRINCIPAL DO MENU */ printf("programa de gestão de alunos\n ); printf(" Escolha uma opção:\n"); printf(" 0: Sair\n"); printf(" 1: Listar alunos\n"); printf(" 2: Acrescentar aluno\n"); printf(" 3: Apagar aluno\n"); printf(" 4: Apagar ficheiro\n"); 3

4 /* LÊ OPÇÃO */ if (scanf(" %d", &opcao)!= 1) { // Foi introduzido um carácter que não é um número getchar(); // Remove carácter do buffer continue; // Volta ao início do ciclo principal getchar(); // Remove '\n' após número /* EXECUTA OPÇÃO */ switch (opcao) { case 0: break; case 1: listar_alunos(argv[1]); break; case 2: adicionar_aluno(argv[1]); break; case 3: apagar_aluno(argv[1]); break; case 4: remove(argv[1]); break; default: printf("%d: opção inválida\n", opcao); while (opcao!= 0); Cada opção é realizada numa função diferente. A opção 4 chama uma função do sistema que apaga um ficheiro. As restantes opções são realizadas com as funções apresentadas nas subsecções seguintes Opção Acrescentar aluno A operação de adicionar um aluno obriga a ler do utilizador dois campos numéricos e um nome. Assim, definem-se duas funções auxiliares, que realizam estas operações. A função ler_nome recebe um array de bytes (nome) e uma variável inteira com a dimensão do array (max_len) e lê uma string com até esse número de bytes, terminada com o terminador de string ( \0 ). A função ler_numero recebe um apontador para um inteiro e modifica o seu valor. Lembre-se que na linguagem C, o nome do array já é um apontador. bool ler_nome(char nome[], int max_len) { nome[0]= '\0'; fgets(nome, max_len, stdin); if (strlen((char *)nome) <= 2) { printf("nome demasiado curto\n"); return FALSE; nome[strlen(nome)-1]= '\0'; // Remove o '\n' do buffer return TRUE; bool ler_numero(int *number_ptr) { return (scanf("%d", /* Já é apontador */number_ptr) == 1); A partir destas funções é possível realizar a função ler_aluno que lê os três campos da variável aluno, um de cada vez. Repare que esta função recebe um apontador para a 4

5 estrutura a preencher, permitindo-lhe modificar o conteúdo da variável aluno. A função funciona integralmente, mas não verifica o valor inteiro do campo turno, que apenas pode ter um valor entre 1 e o valor de MAX_TURNO. #define MAX_TURNO 10 /* Lê os dados referentes a um novo aluno */ bool ler_aluno(struct Aluno *aluno) { printf("nome: "); if (!ler_nome(aluno->nome, MAX_STUDENTNAME_LENGTH)) return FALSE; printf("número: "); if (!ler_numero(&aluno->numero)) return FALSE; printf("número de turno: "); if (!ler_numero(&aluno->turno)) return FALSE; return TRUE; EXERCÍCIO 2: Modifique a função ler_aluno de maneira a passar a retornar FALSE quando o valor do campo turno for inferior a 1 ou superior a MAX_TURNO. Utilizando esta função, pode realizar-se a função adicionar_aluno com o código representado abaixo. Repare que a variável aluno é preenchida dentro da função ler_aluno, e caso esta retorne TRUE (um valor diferente de 0), acrescenta a entrada ao ficheiro. O ficheiro é aberto no modo ab (append, acrescentar no fim e b de binário), e os dados são escritos em formato binário, com a representação que têm na memória na variável aluno, do tipo estrutura struct Aluno. Repare que a escrita é feita passando um apontador para o primeiro byte da variável aluno, indicando o tamanho em bytes ocupado pela variável aluno (sizeof (aluno) ), e o número de alunos que se pretendem escrever (1). O ficheiro é fechado no final, para garantir que os dados estão escritos quando a função termina. void adicionar_aluno(const char *filename) { FILE *fp; struct Aluno aluno; if (ler_aluno(&aluno)) { fp= fopen(filename, "ab"); // "ab" == 'acrescentar' if (fp == NULL) { perror("erro a abrir ficheiro"); return; if (fwrite(&aluno, sizeof(aluno), 1, fp)!= 1) { perror("erro a escrever ficheiro"); fclose(fp); 5

6 2.2.2 Opção Listar alunos A função listar_alunos percorre todos os elementos do ficheiro mostrando-os, um a um. Assim, começa-se por definir a função mostrar_um_aluno que mostra apenas um aluno, escrevendo os seus dados na consola. void mostrar_um_aluno(struct Aluno *aluno) { printf("aluno '%s' no. %d Turno %d\n", aluno->nome, aluno->numero, aluno->turno); A função listar_alunos começa por abrir o ficheiro em modo leitura ( rb de read e binário). Depois, se conseguiu abrir, vai ler entrada a entrada para a variável aluno, escrevendo o seu conteúdo. Repare que a função fread lê directamente 1*sizeof(aluno) bytes para a variável aluno. No final, escreve uma linha em branco e fecha o ficheiro. No entanto, se o ficheiro tem muitos elementos torna-se muito difícil de ler, pois esta função despeja todos os nomes sem nunca parar. #define MAX_LINES 20 void listar_alunos(const char *filename) { struct Aluno aluno; FILE *fp; fp= fopen(filename, "rb"); if (fp == NULL) { perror("erro a abrir ficheiro"); return; while (fread(&aluno, sizeof(aluno), 1, fp)) { mostrar_um_aluno(&aluno); putchar('\n'); fclose(fp); EXERCÍCIO 3: Modifique a função listar_alunos de maneira a que após escrever MAX_LINES linhas, a função pare à espera do utilizador carregar uma tecla. Relembrase que para ler uma tecla pode usar a função getchar() Opção Apagar aluno A função apagar_aluno começa por pedir um número de aluno ao utilizador. Depois, inicia um processo de cópia do ficheiro original para um novo ficheiro temporário, que é igual ao original excepto que não tem o elemento a excluir. A função usa duas variáveis do tipo apontador para FILE em simultâneo: fp_in é usada para ler a partir do ficheiro original; fp_out é usada para escrever no ficheiro temporário. Falta programar uma rotina que leia os alunos, um a um. Deve escrever os alunos em fp_out se tiverem o número de aluno com um valor diferente da variável numero. Caso consiga retirar um aluno, deve modificar o valor da variável Booleana apagou para TRUE. 6

7 void apagar_aluno(const char *filename) { FILE *fp_in, *fp_out; struct Aluno aluno; char temp_outfilename[100]; int numero; bool apagou= FALSE; printf("qual é o número do aluno a apagar? "); ler_numero(&numero); /* Ficheiro original modo leitura */ fp_in= fopen(filename, "rb"); /* Ficheiro temporário com nome único modo escrita */ sprintf(temp_outfilename, "%sxxxxxx", filename); mkstemp(temp_outfilename); // Cria nome único fp_out= fopen(temp_outfilename, "wb"); /* Testa se operações de abertura tiveram sucesso */ if ((fp_in == NULL) (fp_out == NULL)) { perror("erro a abrir um dos ficheiros"); if (fp_in!= NULL) fclose(fp_in); if (fp_out!= NULL) fclose(fp_out); return; // Sai da função /* EXERCÍCIO 4: COMPLETE O CÓDIGO DESTA FUNÇÃO REALIZANDO UMA FUNÇÃO QUE COPIA TUDO O QUE LÊ DE fp_in para fp_out, EXCEPTO QUANDO ENCONTRA O ALUNO COM O NÚMERO IGUAL A numero. SE ENCONTRAR, DEVE COLOCAR A VARIÁVEL apagou COM O VALOR TRUE */ fclose(fp_in); fclose(fp_out); if (apagou) { remove(filename); // Apaga ficheiro original rename(temp_outfilename,filename); //Muda nome de ficheiro else remove(temp_outfilename); // Apaga ficheiro temporário Para facilitar a vida na introdução de um número elevado de alunos foi criado um ficheiro com as opções do menu, os nomes, números e turnos de cada aluno. O Linux permite que se use um ficheiro de entrada em vez do teclado (stdin) se redireccionarmos esse ficheiro para o nosso programa. O ficheiro de texto com os alunos chama-se dados.in e é fornecido com o enunciado. Copie-o para a pasta onde tem o ficheiro executável e corra a seguinte linha de comando que redirecciona o ficheiro dados.in para o programa como se do stdin se tratasse:./alunos alunos.dat < dados.in Quando corre o programa com esta linha, as mensagens escritas em stdout são ainda escritas no ecrã. Se não as quiser ver pode também redireccioná-las para um ficheiro, ou para nada. Um comando para as redireccionar para nada é o seguinte:./alunos alunos.dat < dados.in > /dev/null 7

8 3 Exercício final: Opção Listar por turno Pretende-se neste exercício final, estender o programa desenvolvido anteriormente acrescentando a opção de listar os alunos por turno. Assim, deve acrescentar a opção 5 (Listar por turno), criando uma nova função para tratar a opção. Essa função deve começar por pedir ao utilizador para introduzir um número de turno, e depois listar apenas os alunos que pertencem a esse turno. Este exercício vai ser avaliado pelo docente durante a aula. Caso tenha conseguido terminar durante a aula chame o docente e mostre o trabalho a funcionar. Senão, complete o trabalho após o fim da aula, e traga-o completo para a próxima aula. 8