PROF. MATEUS CONRAD BARCELLOS DA COSTA TÉCNICAS DE PROGRAMAÇÃO AVANÇADA. [ Serra, ES ] [ 2008 ]

PROF. MATEUS CONRAD BARCELLOS DA COSTA TÉCNICAS DE PROGRAMAÇÃO AVANÇADA [ Serra, ES ] [ 2008 ]

CONTEÚDO 1 Abstração de dados... 1 1.1 Introdução... 1 1.2 Conceitos de abstração de dados... 3 1.2.1 Abstração em Computação... 3 1.2.2 Abstração de Procedimentos... 5 1.2.3 Tipos Abstratos de Dados... 6 1.2.4 Implementação de Tipos Abstratos de Dados... 11 1.2.5 Avaliação de Implementações de Tipos Abstratos de Dados... 13 2 Tipos Abstratos de Dados Fundamentais... 17 2.1 Pilhas... 17 2.1.1 Especificação do TAD Pilha... 18 2.1.2 Implementação de Pilhas em Arranjos... 20 2.2 Filas... 22 2.2.1 Especificação do TAD FILA... 24 2.2.2 Implementação de Filas em arranjos com deslocamento... 27 2.2.3 Implementação de Filas com Arranjos circulares... 30 2.3 Implementação de TADS com alocação dinâmica de memória... 32 2.3.1 Revisão de Alocação Dinâmica de Memória... 32 2.3.2 Implementação do TAD Pilha... 32 2.3.3 Implementação do TAD Fila... 36

1 ABSTRAÇÃO DE DADOS 1.1 INTRODUÇÃO Um programa de computador desenvolvido para atender alguma finalidade prática é, normalmente, um artefato complexo. Por este motivo, a atividade de desenvolvimento destes artefatos, a programação de computadores, está entre as atividades mais complexas desempenhadas pelo homem. Se você cursou disciplinas introdutórias de programação, pode estar se questionando: Ora, desenvolver um programa não é tão complexo assim! Basta compreender o problema, suas entradas e suas saídas e construir a solução para o mesmo usando uma linguagem de programação. Simples não? Não! A história da programação tem dado provas que programar não é tão simples assim. Figura 1: O Gap Semântico Programar é uma atividade complexa por diversos aspectos, tanto de cunho teórico quanto prático. Dentre estes aspectos destacamos os seguintes: 1. Programar um computador significa desenvolver programas de computadores (formais e precisos) para atender a finalidades práticas definidas em termos de conceitos do mundo real (informais e imprecisos). Existe um abismo entre o mundo dos problemas reais e o mundo das soluções. Este abismo é chamado na computação de gap semântico. Transpor este abismo é um dos desafios centrais da programação de computadores e da Engenharia de Software como um todo. 2. Muitas vezes, em disciplinas iniciais de programação, nos deparamos com o desenvolvimento de programas mais simples, de cunho didático. Por exemplo, programas para calcular médias ou somatórios. Em outros momentos fazemos programas para aprender a usar um certo mecanismo, por exemplo, apontadores. Aqui, estamos nos referindo a programas de computadores para ajudarem pessoas a resolverem problemas do mundo real, problemas grandes e complexos! Exemplos destes problemas incluem: a. Gerenciar as operações financeiras de uma empresa; b. Controlar uma aeronave; c. Controlar os trens de uma malha ferroviária;

d. Produzir edições diárias de um jornal; e. Gerenciar o processo de produção de um filme. 3. Problemas como estes não são simples de serem resolvidos. Conseqüentemente, programas voltados para estas finalidades são complexos, levam muito tempo para ficarem prontos, têm de ser desenvolvidos por uma equipe de pessoas, utilizando diversas tecnologias e seguindo um processo de desenvolvimento sistemático. 4. Para atender as funcionalidades esperadas, um programa deve apresentar um conjunto de características que juntas vão tornar o programa efetivamente útil e determinarão a qualidade do mesmo. Estas características são as seguintes: a. Um programa deve estar correto, livre de erros; b. Um programa deve ser robusto; c. Um programa deve ser eficiente; d. Um programa deve ser compatível com outros programas; e. Um programa deve ser fácil de usar; f. Um programa deve ser portável, podendo funcionar em diferentes plataformas ou sistemas operacionais; g. Um programa deve ser íntegro, evitar que os dados sejam corrompidos ou violados; h. O processamento realizado pelo programa deve ser verificável; i. O programa ou partes dele devem poder ser utilizados em outros cenários diferentes daquele para o qual o programa foi originalmente desenvolvido. 5. Por último, devemos considerar a atividade de programação enquanto atividade econômica. Assim como outras atividades econômicas, o desenvolvimento de software é regido por leis de mercado que impõem severas exigências aos desenvolvedores. De acordo com estas leis, não basta apenas desenvolver um programa que atenda a finalidade esperada. Estes programas devem ser desenvolvidos dentro dos prazos e custos estabelecidos. Além disso, o programa precisa de ter outras características importantes que permitam a sua evolução. Estas características são chamadas de fatores internos. São eles: a. Facilidade de manutenção; b. Facilidade de evolução; c. Fácil de entender; d. Modular. Pelos motivos discutidos acima, o desenvolvimento de programas requer a aplicação de princípios, métodos e técnicas que diminuam a complexidade deste desenvolvimento. Neste Capítulo iremos discutir e aprender sobre Abstração de Dados. Abstração de Dados consiste tanto de um princípio quanto de uma técnica de programação que visa simplificar o desenvolvimento de programas. Sua aplicação pode se em programas menores. Mas podemos afirmar que seria

impossível o desenvolvimento de sistemas que temos hoje, com milhões de linhas de código, sem o uso de abstração de dados. Nesta introdução foram levantados cinco motivos pelos quais desenvolver software é uma tarefa difícil. Para atacar estes motivos e tornar o desenvolvimento de software mais simples são considerados três dimensões: Processo de desenvolvimento, Pessoas (partes interessadas: clientes, desenvolvedores) e Tecnologias de desenvolvimento. Releia os cinco motivos e tente escrever um texto resumido, estabelecendo uma relação entre estes 5 motivos e estas três dimensões. 1.2 CONCEITOS DE ABSTRAÇÃO DE DADOS 1.2.1 Abstração em Computação A abstração é um dos conceitos mais importantes da computação. Sem a sua podemos afirmar que a evolução apresentada pela computação teria sido mais lenta. Segundo o dicionário Michaeles, temos a seguinte definição para a palavra Abstração: O ato ou efeito de abstrair. Consideração das qualidades independentemente dos objetos a que pertencem. Abstrair : Considerar um dos caracteres de um objeto separadamente; Excluir, prescindir de. A finalidade principal de uso de abstração em qualquer área do conhecimento é colocarmos foco em um sub-conjunto dos aspectos de um sistema ou processo complexo. Considere, por exemplo, o processo de pintar um quadro. A Figura abaixo mostra, à esquerda um esquema inicial mostrando as linhas principais do quadro que se encontra ao lado direito (A Virgem, o Menino e Sant Ana, Leonardo Da Vinci).

Observe que no desenho, as proporções, os detalhes das posturas e feições são já determinadas. Este processo ajuda o pintor pois, no momento da idealização do quadro, ele não precisa se preocupar com outros aspectos complexos, como cores, nuances de sombras e reflexos, para definir a estrutura e a sua aparência geral. Podemos dizer então que o desenho à esquerda é uma abstração do quadro. Em computação, abstração também possui finalidades semelhantes. Em programação especificamente, este conceito está presente quase o tempo todo, seja nas construções existentes nas linguagens, seja nos métodos de programação empregados. Uma das principais abstrações de linguagens de programação é o conceito de variável. Uma variável é um conceito abstrato que esconde diversos aspectos técnicos que não interessam ao programador. Quando declaramos uma variável em um programa, esta declaração implica em coisas que não irão interferir no desenvolvimento do mesmo. Por exemplo, por trás de uma variável do tipo inteiro em C, (ex. int x;), estão escondidos as características físicas do armazenamento da variável em memória, a saber: - A forma de representação de números inteiros usando base 2 (por exemplo, complemento de 2); - O padrão usado pelo hardware (little endian, big endian) [Ver em http://pt.wikipedia.org/wiki/little_endian]; - O número de bytes que uma variável do tipo inteiro ocupa; - O endereço da variável na memória principal; - O conjunto de bits responsável por armazenar o sinal do número inteiro; Para o programador em C, geralmente, nenhuma destas informações é importante. O que o programador deseja, é utilizar a variável realizando as operações permitidas aos número inteiros (operações aritméticas e comparações), atribuir, recuperar e modificar o valor contido na variável. Assim podemos dizer que uma variável permite ao programador abstrair-se de detalhes que não interessam e não irão influenciar no comportamento do programa. Os elementos a seguir são todos abstrações. Para cada um deles descreva os aspectos que estão sendo escondidos e os aspectos que realmente importam ao programador: 1. O comando if(){.. else{.. 2. um arquivo 3. a função scanf

1.2.2 Abstração de Procedimentos Podemos afirmar que a grande maioria dos elementos de linguagem utilizados em uma linguagem de programação de alto nível são abstrações. Estas abstrações facilitaram o desenvolvimento de programas mais complexos e sofisticados, evitando que programadores precisassem manipular bits, endereços de memória e interagir diretamente com o sistema operacional. Uma outra abstração de programação importante é a Abstração de Procedimento. A abstração de procedimento permite que o programador crie, ele mesmo, sua forma de abstrair, utilizando os comandos disponíveis na linguagem. A possibilidade de criar procedimentos permite ao programador criar funcionalidades mais abstratas que escondem a seqüência de operações necessária para a realização de uma tarefa complexa. Por exemplo, sabemos que na linguagem C não existe um comando que seja capaz de ordenar um vetor de inteiros em ordem crescente. Seria muito bom que pudéssemos contar com este comando, certo? Mas, como não temos este comando, iremos criar uma função (abstração de procedimento) que realize esta tarefa para nós. A função ordena no, quadro abaixo, é esta abstração. void ordena(int a[], int tamanho) { int i, j, valor; for(i = 1; i < tamanho; ++i) { value = a[i]; for (j = i - 1; j >= 0 && a[j] > value; --j){ a[j + 1] = a[j]; a[j+1] = valor; Após a implementação da função ordena, quando o programador precisar ordenar um vetor, basta que ele invoque a função, passando os parâmetros necessários. Ou seja, ao usar o procedimento o programador irá se preocupar apenas com o que a função faz e não mais com os detalhes de sua implementação. Uma abstração de procedimento deve realizar uma tarefa (por exemplo, ordenar um vetor de inteiros) que deve ser independente da forma como este vai ser implementado. O programador deve antes de tudo ver o procedimento como uma caixa preta, cuja especificação deve conter três elementos básicos:

Entrada: O conjunto de dados de entrada necessário; Saída: O conjunto de dados produzido pelo procedimento; Função (o que o procedimento faz). ENTRADA FUNÇÃO SAÍDA Na especificação do procedimento, o programador não deve estar preocupado com a implementação, mas sim com o comportamento (função) do mesmo. Qualquer implementação que realize a função especificada irá servir. Para o caso da ordenação, veremos adiante neste curso que existem diferentes métodos de ordenar um vetor. O método utilizado na função ordena se chama ordenação por inserção. A implementação internar poderia ser substituída por qualquer outro método de ordenação. A própria linguagem C oferece em sua biblioteca padrão stdlib, uma função chamada qsort, que pode ser usada para ordenar vetores. Esta função utiliza um outro método de ordenação muito conhecido e também muito rápido, chamado de Quick Sort. 1. Suponha que você tenha disponíveis as seguintes funções em C: int CalculaMedia(int *notas); void DeterminaMaiorEMenorNotas(int *v, int * maior, int *menor); void lenotas(int *notas); void MostraResultados(int media,int maiornota, int menornota); Desenvolva um programa em C usando estas funções que leia as notas de 5 turmas e para cada uma delas, imprima a média, a maior e a menor nota. 1.2.3 Tipos Abstratos de Dados Abstração de dados visa aos mesmos objetivos que a abstração de procedimentos, mas, com relação às estruturas de dados utilizadas nos programas. A abstração de dados visa criar novos tipos de dados definidos em temos de seu comportamento. Estes novos tipos são chamados de Tipos Abstratos de Dados - TAD. É muito importante que você perceba que um tipo abstrato de dados não se resume a uma nova estrutura de dados. Vamos então discutir um pouco sobre esta diferença. Primeiramente, uma estrutura de dados pode ser definida de maneira geneérica como uma variável capaz de armazenar mais de um valor simultaneamente. Assim, um vetor, uma matriz ou um registro (struct em C) são exemplos de estruturas de dados. A combinação destes elementos em estruturas mais

complexas dá origem a outras estruturas de dados. As declarações de struct ponto e struct reta são exemplos de tipos de estruturas de dado. struct ponto{ float x, y; ; struct reta { struct ponto a,b; ; Ao definir a struct ponto, passamos a contar com mais uma alternativa para definição de tipos de variáveis e, conseqüentemente para a composição de novos tipos de estruturas. Assim a struct reta foi definida como uma composição de duas variáveis do tipo struct ponto. Estas estruturas podem ser usadas para declarar tanto variáveis como argumentos de funções. Em C temos ainda a cláusula typedef que permite definir o nome do novo tipo. Daí que não precisamos usar a palavra reservada struct. No quadro a seguir abaixo temos o uso de typedef. Veja que na definição do tipo Reta, o nome Ponto é usado sem a palavra reservada struct. typedef struct { float x, y; Ponto; typedef struct { Ponto a,b; Reta; A definição de uma estrutura de dados se preocupa em como o objeto é representado na memória de um computador (representação). Nesta definição são considerados aspectos do tipo: quais as informações que serão armazenadas ali e qual a quantidade destas informações. A definição de um Tipo Abstrato de Dados segue uma abordagem diferente. Esta definição é feita em termos das operações que podem ser realizadas sobre o tipo. A definição de um Tipo Abstrato de Dado (TAD) é chamada de especificação e consiste, basicamente, em definir as operações relacionadas ao tipo. Dizemos que estas operações definem o comportamento do TAD. Vamos ilustrar esta definição considerando também os objetos Reta e Ponto. Bem, um passo importante na definição do TAD, que já ajuda na programação de uma maneira geral, é que não conseguimos defini-lo sem conhecermos a sua finalidade e o contexto no qual este será usado. Em nosso exemplo, precisamos saber para que nos queremos um ponto e uma reta. Geralmente esta informação é conseguida a partir do enunciado do problema. Assim suponha a seguinte descrição para o nosso problema envolvendo retas e pontos. Problema A. É necessário um programa de computador que realize operações geométricas envolvendo pontos e retas localizadas no plano cartesiano. O programa deve permitir: calcular a distância do ponto até a origem do plano cartesiano; calcular a distância entre dois pontos; dada a representação da reta por dois pontos, calcular o ângulo de inclinação da reta, fornecer os parâmetros a e b correspondentes a equação da reta ax +b. Determinar a

distância de uma reta a um ponto. Evidentemente, o programa deve permitir a leitura e impressão de pontos e retas conforme a necessidade das operações. Com base na descrição acima podemos identificar a ncessidade do TAD ponto e do TAD Reta, bem como suas operações. Estas operações aparecem sublinhadas no texto do problema e são organizadas a seguir: Operações TAD Ponto: - Calcular Distancia do ponto até a Origem do plano cartesiano - Calcular Distância até outro ponto - Ler um ponto - Imprimir um ponto Operações TAD Reta: - Calcular o ângulo de inclinação da reta - Calcular os parâmetros a e b - Calcular a Distância da reta a até um ponto - Ler uma reta representada por dois pontos - Imprimir uma reta representada por dois pontos Agora, considere que estejamos desenvolvendo um programa para o problema abaixo: Problema B. É necessário um programa de computador para apresentar graficamente figuras geométricas formadas por pontos e retas, usando o monitor do computador como plano. O programa deve permitir: Ler um ponto, plotar um ponto na tela, ligar dois pontos por um segmento de reta, dada uma reta passando por este ponto, deslocar um ponto com base na equação desta reta; Data uma reta representada por dois pontos, plotar esta reta no monitor, Dada uma reta, e um valor d, criar uma reta paralela a reta dada a uma distancia d da reta. As operações necessárias aos TAD Ponto e Reta neste problema são as seguintes: Operações TAD Ponto: - Ler um ponto - Plotar um ponto - Ligar dois pontos - Deslocar um ponto Operações TAD Reta: - Ler uma Reta - Plotar uma Reta - Criar Reta Paralela

Note que nos dois problemas tinhas os tipos Ponto e Reta. No entanto, a abstração necessária para um problema difere do outro, interferindo na definição das operações. Iremos sempre tentar criar abstrações mais genéricas o quanto for possível. Quanto mais genérico um TAD, maior o um número de problemas em que este poderá ser aplicado. Embora as operações não informem nada a respeito da representação interna de um TAD, elas fornecem ao programador tudo que ele precisa para manipular o TAD. As operações de um TAD especificam a sua interface com o restante do programa. Isso significa que qualquer ação relacionada ao TAD deve ser feita mediante uma de suas operações. Como resultado prático disto, temos que, o programador poderá usar as operações do TAD sem se preocupar com a sua implementação, invocando apenas as suas operações. Vejamos um exemplo, Suponha que tenhamos definido e implementado os TAD Ponto e Reta segundo a definição feita para o problema A. Os tipos forma definidos e implementado, originando dois módulos independentes: o Módulo Ponto e o Módulo Reta. Cada módulo em C geralmente implementado por dois arquivos: o arquivo.h e o arquivo.c. No arquivo.c teremos a implementação das operações do TAD e no arquivo.h teremos a especificação da interface do TAD. A seguir apresentamos as interfaces dos módulos Ponto e Reta. // interface do Tad Ponto: ponto.h typedef struct ponto { int x, int y; Ponto; void lerponto(ponto *); void distanciaorigem(ponto); void distancia2pontos(ponto,ponto); // interface do Tad Reta: Reta.h typedef struct reta { struct ponto a,b; Reta; void lerreta(reta *); void distanciaretaponto(reta,ponto); void InclinacaoReta(Reta); void equacaoreta(reta); Com a implementação dos TAD Ponto e Reta concluídas e devidamente testadas, qualquer outro módulo do programa poderá utilizar estes tipos por meio das operações definidas para os mesmos. Quando um módulo A utiliza um módulo B em programação, dizemos que o módulo A é cliente do módulo B. Esta relação de clientela entre os módulos (ou TADs) de um programa pode ser representada graficamente por meio de um diagrama de estrutura modular - DEM.

Um diagrama de estrutura modular é formado por retângulos e Linhas direcionadas. Cada retângulo representa um módulo. As Retas direcionadas significam cliente de. Como exemplo, suponha que tenhamos também junto aos módulos Ponto e Reta, um módulo chamado principal. Este módulo é cliente dos módulos Ponto e Reta. A Figura a seguir ilustra o DEM deste programa: Ponto Reta Principal O quadro a seguir ilustra a implementação de um módulo Principal. Note que aa única forma de acesso aos TADs Ponto e Reta é por meio das operações definidas em suas respectivas interfaces. Implementar as operações do TadPonto e do TadReta e desenvolver um programa usando a função principal (do quadro a seguir) de forma a testar as operações.

void principal() { char opcao; Ponto p1,p2; Reta r1; printf("1- Calcular Distância até a origem.\n"); printf("2- Calcular Distância entre pontos.\n"); printf("3- Calcular Distância de uma reta a um ponto.\n"); printf("4- Determinar inclinação da reta.\n"); printf("5- Determinar equação da reta.\n"); printf("0- Sair.\n"); printf("informe a opção Desejada: "); do{ opocao = getchar(); switch(opcao){ case '1': lerponto(&p1); distanciaorigem(p1); break; case '2': lerponto(&p1); lerponto(&p2); distancia2pontos(p1,p2); break; case '3': lerreta(&r1); lerponto(&p1); distanciaretaponto(r1,p1); break; case '4': lerreta(&r1); inclinacaoreta(r1); break; case '5': lerreta(&r1); equacaoreta(r1); break; default: printf("informe uma Opção Válida."); while(opcao!='0'); 1.2.4 Implementação de Tipos Abstratos de Dados Uma das principais conclusões sobre abstração em programação que podemos tirar até agora é que o propósito da abstração na programação é separar

comportamento de implementação. Até o momento, em nosso exemplo de envolvendo Ponto e Reta, propositalmente não abordamos a questão de como as operações serão implementadas. E mais, neste ponto do desenvolvimento não precisamos saber mesmo. Você por acaso se lembra como se calcula a distância entre dois pontos? E a distância entre uma reta e um ponto? Pois bem, o importante é que, você tenha compreendido a discussão feita e o exemplo dado, sem saber responder estas duas perguntas [assim espero! ]. O que definimos a respeito dos TAD Ponto e Reta foi o seu comportamento, as suas operações. O projeto completo de um TAD consiste de dois passos: 1. Especificação - Consiste na especificação do comportamento do TAD; 2. Implementação Implementação das operações e estruturas de dados. Especificação A especificação de um TAD descreve o que TAD faz mas omite informação sobre como o mesmo é implementado. Por omitir detalhes de implementação, para uma especificação podem existir muitas implementações diferentes. A especificação é feita por meio da definição das operações do TAD. Para detalhar melhor cada uma destas operações, deve-se estabelecer três elementos: - Pré-condições: definem as condições necessárias para que a operação possa ser realizada. Por exemplo, suponha que desejamos especificar o TAD Conjunto com a operação listarelementos. Um pré-condição desta operação é que o Conjunto não esteja vazio. - Pós condição: definem estado do TAD após a execução do operação. Considerando ainda o TAD conjunto. Por exemplo, suponha a operação inserirelemento no TAD conjunto. Uma pós-condição para esta operação seria: elementos no conjunto = elementos no conjunto + novo elemento. O quadro a seguir ilustra a definição do TAD conjunto. TAD Conjunto: Operações: inserirelemento - Pré-condições: conjunto cheio == FALSO - Pós Condições: elementos no conjunto = elementos do conjunto + novo elemento listarconjunto - Pré-Condições: conjuntovazio == FALSO - Pós-Condições: não há Implementação Um TAD é implementado por um módulo de um programa. Conforme já discutimos, uma única especificação permite diferentes implementações. Uma implementação está correta se esta provê o comportamento especificado para o TAD. Implementações corretas podem diferir uma da outra, por exemplo em termos do algoritmo ou da estrutura de dados que elas usam. Estas diferenças

interferem no desempenho (tempo de execução) apresentado pelo TAD para realização das operações. Para uma abstração funcionar corretamente, a sua implementação deve ser encapsulada. Se a implementação for encapsulada nenhum outro módulo do programa vai depender de detalhes de implementação do TAD. Encapsulamento garante que módulos do programa podem ser implementados e reimplementados independentemente, sem afetar os outros módulos do programa. O encapsulamente geralmente é conseguido por meio da separação da interface e da implementação do módulo. Conforme já vimos anteriormente, em C a implementação de um TAD por meio de um módulo consiste em duas partes: a especificação da interface do módulo por meio do arquivo header ( com extensão.h) e da implementação das operações por meio de um arquivo com extensão.c. 1.2.5 Avaliação de Implementações de Tipos Abstratos de Dados Embora a linguagem C não ofereça um mecanismo que impeça realmente que o programador tenha acesso a estrutura interna do TAD, esta é uma regra fundamental e deve ser respeitada pelo programador. Esta regra ou característica de TADs é o encapsulamento, discutido na seção anterior. Dizemos que um TAD é encapsulado por suas operações, no sentido de que a estrutura interna do TAD fica preservada e invisível ao restante do programa. Violar esta regra significar não usar corretamente a abstração de dados. A maior vantagem do encapsulamento se chama princípio da Localidade. Localidade permite que um programa seja implementado, entendido e modificado um módulo de cada vez: 1. O programador de uma abstração sabe o que é necessário pelo que está descrito na especificação. Desta forma, ele não precisa interagir com programadores de outros módulos (ou, pelo menos, esta interação vai ser bem limitada). 2. De forma análoga, o programador de um módulo que usa a abstração sabe o que esperar desta abstração pelo comportamento descrito em sua especificação. 3. É necessário apenas o raciocínio local (por módulo), para saber o que o programa faz e se está fazendo a coisa certa. O programa pode ser estudado e compreendido um módulo de cada vez. Em cada caso, nos preocupamos em saber se o módulo faz o que é suposto que faça. Ou seja, se ele cumpre o que está na especificação. Pode-se assim limitar a atenção para um módulo, ignorando tanto os módulos usados por este quanto os que o utilizam. Os módulos que o utilizam podem ser ignorados porque dependem apenas de sua especificação e não da sua implementação. Os módulos utilizados são ignorados raciocinando-se sobre o que eles fazem utilizando apenas sua especificação ao invés de sua codificação. Com isto se tem uma grande economia de esforço, dado que as especificações são muito menores que as implementações. Observando-se apenas as especificações evita-se também um efeito cascata. Por exemplo, se tivermos que olhar o código do módulo

que utilizamos, teremos que olhar também o código dos módulos que são utilizados pelos módulos que utilizamos e assim por diante. 4. Finalmente, a modificação do programa pode ser feita módulo por módulo. Se uma abstração particular necessita ser reimplementada para prover um melhor desempenho, corrigir um erro ou prover uma nova funcionalidade, o módulo implementado anteriormente pode ser trocado por uma nova implementação sem afetar os outros módulos. Localidade também provê uma base firme para a prototipação ou prototipagem. Um protótipo é uma implementação rudimentar e incompleta do programa que queremos desenvolver. Se mantivermos o princípio da localidade no desenvolvimento do protótipo, a implementação inicial do programa pode ser simples e incompleta. Posteriormente, esta pode ir sendo completada ou substituída por implementações melhores sem grande esforço nem re-trabalho. Localidade também provê suporte para evolução. Abstrações podem ser utilizadas neste caso para encapsular modificações potenciais no programa. Por exemplo, suponha que desejamos um programa para executar em diferentes máquinas. Podemos tratar este problema inventando abstrações que escondam as diferenças entre as máquinas de forma que, para mover o programa para uma máquina diferente, apenas estas abstrações precisem ser reimplementadas. Um bom princípio de projeto é pensar sobre modificações esperadas e organizar o desenvolvimento utilizando abstrações que encapsulem as mudanças. Os benefícios da localidade são particularmente importantes para a abstração de dados. Estruturas de dados são muitas vezes complicadas e a visão mais abstrata mais simples provida pela especificação torna o resto do programa mais simples. Ainda, mudanças nas estruturas de armazenamento são uma das principais formas de evolução de programas. Portanto, os efeitos destas mudanças devem ser minimizados encapsulando estas estruturas de dados em abstrações de dados. Resumidamente se avaliarmos um programa segundo o critério da abstração de dados, devemos observar os seguintes fatores: 1. Os TADs estão realmente encapsulados? a. O entendimento de cada módulo do programa independer dos demais módulos? b. O efeito cascata é evitado na depuração? c. É possível re-implementar um módulo sem afetar os outros? 2. Potenciais mudanças foram prevista no projeto do TAD? 3. Os TADs oferecem abstrações suficientemente simples das estruturas de dados que encapsulam?

Os códigos a seguir especificam as interfaces dos módulos Aluno e Turma. /**************** aluno.h *******************/ typedef struct aluno{ char nome[30]; int matricula; int cdgcurso; Aluno; void lealuno(aluno *); void imprimealuno(aluno); void AlteraAluno(Aluno *); /******************* turma.h *****************/ #include "aluno.h" #define MAXTURMA 100 typedef struct turma { int nalunos; Aluno alunos[maxturma]; Turma; void inserealuno(turma *,Aluno); /*insere o aluno passado como paramentro na turma */ void localizaaluno(turma *, char *); /* localiza um aluno na turma pelo nome */ void imprimeturma(turma); void atualizaalunodaturma(turma *, char *); Agora, suponha que tenhamos o seguinte módulo principal, utilizando estes módulos: /****************** Modulo Principal ***************/ #include "turma.h" Turma turma1; void principal(){ int opcao,i; aluno a; char nome[30]; do{ scanf("%d",&opcao); switch(opcao){ case 1: /* cadastrar aluno */ lealuno(&a); inserealuno(&turma1,a); break; case 2: /* imprimir os dados de um aluno cujo nome é xxx*/ scanf("%s",nome); a= localizaaluno(&turma1, nome); printf("%s - %d - %d",a.nome, a.matricula,a.cdgcurso); break; case 3: /* imprimir turma */ for (i=0;i<turma.nalunos;i++)

imprimealuno(turma.alunos[i]); break; case 4: /* alterar dados de um aluno */ scanf("%s",nome); atualizaalunodaturma(&turma1, nome); break; Tarefas: a) Critique a implementação do módulo acima com base nos critérios de avaliação de TADs discutidos acima. b) Faça uma implementação da operação atualizaalunodaturma, respeitando os princípios de programação baseada em tipos abstratos de dados. Dijkstra (2002), foi, sem dúvida um dos cientistas que mais contribuíram para o desenvolvimento da Computação. Terminamos este capítulo com uma frase dele, que resume o conceito de abstração: O propósito da abstração não é ser vaga, mas sim, criar um novo nível semântico no qual ela possa ser absolutamente precisa. Edsger. W. Dijkstra, The Humble Programmer (O programador Mediocre), Communications of the ACM, 15(10), 1972. Reflita sobre isso!

2 TIPOS ABSTRATOS DE DADOS FUNDAMENTAIS No decorrer da história da programação, padrões e práticas comuns têm sido observadas e transformadas em conceitos, modelos e mecanismos que podem ser utilizados em mais de uma situação diferente. Dentre estes elementos temos uma coleção de tipos abstratos de dados. Estudaremos alguns destes TADs neste capítulo. 2.1 PILHAS No mundo real uma pilha corresponde a um agregado de objetos que são acomodados um sobre o outro. A Figura abaixo ilustra uma pilha onde os objetos são caixas. 4 3 2 1 Pilha de Caixas Os números nas caixas indicam a ordem de empilhamento. Se quisermos agora remover as caixas da pilha (desempilhar), temos que remover a caixa 4 primeiro, depois a 3, 2 e finalmente a 1. Não podemos remover as caixas abaixo da que está no topo da pilha sem antes remover a do topo. Este comportamento pode ser definido pela estilo: O último a entrar é o primeiro a sair. No mundo real temos diversas situações em que este comportamento deve ser respeitado. Assim, o uso de pilhas pode facilitar na solução de vários problemas. Um exemplo típico de uso de pilha é a operação desfazer, presente na maior parte dos editores de texto. Quando voce executa a operação desfazer, a última operação realizada é que deverá ser desfeita. Se voce executar o desfazer novamente, a penúltima operação deverá ser desfeita, e assim sucessivamente. Concluindo, precisamos ter sempre a informação de qual foi a última operação realizada. Um pilha é uma forma eficiente de obtermos esta informação. Se tivermos uma pilha onde empilhamos a operação que foi feita, teremos no topo da pilha sempre a operação que devemos desfazer. Realmente, editores texto que possuem a operação desfazer mantem uma pilha que guarda informações sobre as ações que vão sendo realizadas durante a

edição. Por exemplo, no momento em que este texto era digitado, as informações passadas via teclado e mouse eram também empilhadas. A aplicação de pilhas em editores de texto é um exemplo muito comum de uso de pilha. Esta aplicação está presente em outros cenários, como em jogos, programas de logistica, robótica e redes de computadores. O que estes cenários tem em comum é a necessidade de retroceder por um caminho de dados ou ações que tenha realizado. Este retocesso se dá também em algoritmos de backtracking, (algo como voltar na trilha). Este retrocesso é muito comum em algoritmos de busca e recuperação de informação [ver http://pt.wikipedia.org/wiki/backtracking]. 1. Na seqüência a seguir, uma letra significa empilha e um asterisco significa desempilha. Determine a seqüência de valores retornados pela operação desempilha quando esta seqüência de operações é realizada sob uma pilha inicialmente vazia. E A S * Y * Q U E * * * S T * * * I O * N * * * 2. Suponha que uma seqüência misturada de operações empilha e desempilha são realizadas. As operações empilha, empilham inteiros de 0 até 9 ordenadamente. A operação desempilha, desempilha e imprime o valor desempilhado. Qual das seqüências abaixo não poderá ser impressa? (a) 4 3 2 1 0 9 8 7 6 5 (b) 4 6 8 7 5 3 2 9 0 1 (c) 2 5 6 7 4 8 9 3 1 0 (d) 4 3 2 1 0 5 6 7 8 9 2.1.1 Especificação do TAD Pilha O tipo abstrato de dados pilha pode ser descrito pela seguinte especificação:

TAD Pilha Operações: inicializapilha(pilha) - Pré-condições: não há - Pós-Condições: faz Pilha vazia empilhar(pilha, elemento) - Pré-condições: pilhacheia igual==falso - Pós-Condições: insere elemento na pilha; atualiza topo Desempilhar(Pilha) - Pré-Condições: pilhavazia == FALSO - Pós-Condições: remove elemento do topo da pilha; atualiza topo Além das operações empilha e desempilha temos também a operação inicializapilha, que coloca a Pilha em um estado inicial, com a pilha vazia. A Figura a seguir ilustra uma possível implementação de pilha limitada a cinco (5) posições. Cada posição possui um índice. O topo, mantém o índice do valor que está presente no topo. Neste exemplo, temos que o elemento do topo está na posição de índice 5, conforme indica a figura. Se convencionarmos que os elementos foram inseridos na pilha na ordem L I C A F, temos que: O primeiro elemento empilhado foi o L, seguido do I, C, A e F. Logo, podemos concluir que nesta implementação de pilha a atualização do topo consiste em incrementar de 1 na operação empilha e decrementar de 1 na operação desempilha. As pré-condições também podem ser obtidas da implementação. A operação Pilha Vazia pode ser verificada por meio do teste do valor do topo. Por exemplo, se iniciarmos a pilha com topo valendo 0, podemos usar o teste topo == 0 para verificar se pilha está vazia. Já a pré-condição pilha cheia pode ser verificada considerando o limite da implementação. No nosso exemplo este limite é 5. Se o topo == 5 a pilha está cheia. Com isto fica definida também a operação inicializapilha que devem fazer o topo valer 0 (zero). 5 F 4 A 5 3 C topo 2 I 1 L

O importante neste momento é notar que existem muitas implementações possíveis para a especificação do TAD pilha (conforme previsto e discutido no capitulo 1). Este exemplo apresentado é apenas uma das possíveis soluções. Um outro detalhe é que, além das operações empilhar e desempilhar, as précondições de pilha Cheia e pilha Vazia podem também se tornar operações do TAD Pilha na implementação. Na próxima seção discutimos algumas implementações de Pilha usando arranjos estáticos. 2.1.2 Implementação de Pilhas em Arranjos A Figura anterior ilustra uma implementação de Pilha. Usando arranjos estáticos e fazendo algumas adaptações podemos criar esta implementação em C. A implementação, conforme discutido no capítulo 2 será formado de duas partes, a inrterface (arquivo com extensão.h) e a implementação das operações (arquivo com extensão.c). É recomendado primeiro a definição do arquivo de interface e depois do de implementação das operações. A seguir discutiremos uma possível implementação do TAD Pilha, utilizando arranjos. O Quadro a seguir mostra o arquivo de interface tadpilha.h. Foi definido um novo tipo chamado Pilha, formado por dois elementos principais: Uma variável inteira topo e o vetor itens que servirá de contêiner para a pilha. O vetor itens é do tipo Elemento, que é apenas uma redefinição do tipo char. A definição deste tipo Elemento facilita posteriores modificações no tipo básico da pilha. Se quisermos, por exemplo, alterar a pilha para que esta empilhe e desempilhe valores inteiros, basta redefinir o tipo Elemento como int. Foram definidas assinaturas (protótipos) das funções correspondentes às operações inicializapilha, empilha, desempilha e aos testes das pré-condições, pilhacheia e pilhavazia. Obsereve que estamos seguindo a notação de protótipos padrão de C. Nesta notação, apenas os tipos dos argumentos (parâmetros das funções) são identificados, sendo os nomes dos mesmos definidos apenas na implementação. Note também que a operação desempilha retorna um Elemento. Isso é bastante comum, pois normalmente deseja-se fazer alguma coisa com o elemento desempilhado.

/* * Interface do Tad Pilha * Especifica uma pilha para empilhar e desempilhar caracteres * */ #define MSG_PILHAVAZIA "\na Pilha está vazia\n" #define MSG_PILHACHEIA "\na Pilha está cheia\n" #define MAX 5 // tamanho máximo da Pilha #define TRUE 1 #define FALSE 0 typedef char Elemento; // tipo a ser armazenado typedef struct { int topo; Elemento itens[max]; Pilha; int pilhacheia(pilha); int pilhavazia(pilha); void inicializapilha(pilha *); void empilha (Pilha *, Elemento); int desempilha (Pilha *, Elemento); A seguir temos a implementação das operações, feitas no arquivo tadpilha.c. A operação inicializapilha faz o topo da Pilha receber 0 (zero). PilhaCheia verifica se topo igual a MAX (tamanho máximo que a pilha pode ter) e PilhaVazia verfica se topo igual a 0. Na operação empilha temos a seguinte ordem: insere o elemento e depois incrementa o topo. Isso é necessário porque em C a primeira posição de um arranjo é a zero e a Pilha vazia o topo está em zero. Assim o topo estará sempre com um índice do elemento no topo + 1. Para compensarmos isso, na operação desempilha devemos: decrementar o topo retornando o elemento somente após o topo ser decrementado. Exercício: Empilhamento decrescente. Uma empilhadeira carrega caixas de 7, 5, 3 toneladas. Há três pilhas A, B, C. A pilha A é onde se encontram todas as caixas que chegam no depósito. Com um detalhe: caixas maiores não podem ser empilhadas sobre caixas menores. Elabore uma função chega_no_deposito (Caixa* nova, Pilha* A) que efetue o controle das caixas, de forma que caso uma caixa de maior peso do que uma que já está em A deva ser empilhada, então, todas as caixas que estão em A são movidas para as pilhas auxiliares B (contendo somente caixa de 5 toneladas) e C (contendo somente caixas de 3 toneladas) até que se possa empilhar a nova caixa. Depois, todas as caixas são movidas de volta para a pilha A.

/* * tadpilha.c * Implementação das operações do Tad Pilha * * */ void inicializapilha(pilha *p) { p->topo=0; int pilhacheia(pilha){ return(pilha.topo==max); int pilhavazia(pilha p){ return (p.topo==0); void empilha (Pilha *p, Elemento ele){ if (pilhacheia(*p)==false) { p->itens[p->topo] = ele; p->topo++; else{ fprintf(stderr, MSG_PILHACHEIA); int desempilha(pilha *p, Elemento *ele) { if (pilhavazia(*p)==false) { p->topo--; *ele = p->itens[p->topo]; return(true); return(false); Implementar o TipoAbstrato PilhaDupla, usando um arranjo de 100 posiçoes. O Tipo, deve usar um único arranjo para implementar as duas pilhas. Além disso a ocupação da Pilha deve maximizar o uso do espaço do arranjo, ou seja. Enquanto houver espaço no arranjo qualquer uma das duas pilhas pode utilizá-lo. 2.2 FILAS

Em nosso cotidiano nos deparamos constantemente com filas. Ou melhor, estamos constantemente entrando e saindo de filas! Muitas pessoas se aborrecem com as filas. Todavia, podemos dizer que elas são um mal necessário. Por exemplo, imaginem se, para entrarem em um ônibus em uma cidade, as pessoas não fizessem um fila e simplesmente se amontoassem na porta. Seria um tumulto, as pessoas que estivessem no ponto a mais tempo poderiam não conseguir entrar ou ficar sem assento. O mais incrível é que isso acontecia a uns 20 anos atrás e ainda acontece em muitos lugares do Brasil e do mundo! Figura 2: Fila: O primeiro que chega é o primeiro a ser atendido. Este exemplo ilustra que o emprego de filas no dia-a-dia é fundamental para a organização das atividades feitas pelas pessoas, sempre que: o número de clientes de um recurso é maior que a capacidade de atendimento do mesmo. No caso do ônibus, o recurso é a porta de entrada, que só atende uma pessoa por vez. Com mais de uma pessoa no ponto a esperar por entrar, é necessário que elas formem uma fila. Um outro exemplo é fila em um banco. Nesta o recurso é o caixa. Quando entram mais clientes do que o número de caixas, os clientes devem formar uma fila. O comportamento de uma fila pode ser descrito pelo estilo: O primeiro que chega é o primeiro a ser atendido. Na programação aplicamos o conceito de fila para tratar casos semelhantes ao do ônibus e do banco. Alguns exemplos de aplicação de filas são: Fila de espera de passagens aéreas Suponha, por exemplo, que você esteja desenvolvendo um sistema de reservas de passagens aéreas. Neste tipo de sistema, as pessoas fazem reservas até o recurso (número de assentos no vôo) se esgotar. Quando isso acontece, se houver mais pessoas que querem viajar naquele vôo, elas entram em um fila de espera. Se houver uma desistência das reservas, a primeira pessoa desta fila será atendida. Fila de mensagens Suponha que você esteja desenvolvendo um programa A que envie constantemente mensagens a um programa B. O programa B precisa receber estas mensagens e processá-las. Se o número de mensagens que o programa A envia em um tempo x é maior do que a capacidade de processamento das mensagens no mesmo tempo x pelo programa B, o programa B deverá usar uma fila para guardar as mensagens até que estas possam ser processadas. Este é um caso muito comum na Internet. Quando fazemos a requisição de uma página Web, o navegador (programa A) envia uma mensagem o servidor Web

(programa B). Este servidor pode receber mais requisições (mensagens) do que a sua capacidade de processamento. Neste caso, ele deve enfileirar as requisições para que estas não sejam perdidas e para que sejam atendidas na ordem de chegada. O estudo das Filas, do ponto de vista estatístico e probabilístico, denominase Teoria das Filas e compreende uma disciplina de grande interesse de diversas áreas da engenharia, computação e administração. Esta disciplina permite, dentre outras coisas: estimar a capacidade de recursos a serem construídos (p.exemplo, aeroportos, pontes, armazéns de estocagem), identificar gargalos (pontos de atraso) em sistemas e estimar o tempo para a realização de uma tarefa. Em nosso estudo, nos concentraremos apenas na implementação e emprego de filas em programas e não na Teoria das Filas. 2.2.1 Especificação do TAD FILA O tipo abstrato de dados fila pode ser descrito pela seguinte especificação: TAD Fila: Operações: inicializafila(fila) - Pré-condições: não há - Pós-Condições: faz a Fila vazia inserir(fila, elemento) - Pré-condições: filacheia igual==falso - Pós-Condições: insere elemento no final da fila; atualiza o final remover(fila) - Pré-Condições: filavazia == FALSO - Pós-Condições: remove elemento do inicio da fila; atualiza inicio As operações fundamentais do TAD Fila são inserir e remover. Para garantir o comportamento esperado em um fila, definimos que a inserção é feita no final da fila e a remoção é feita no começo da fila. Temos também a operação inicializafila que coloca a fila em um estado inicial, no qual a fila deve estar vazia. A partir destas operações e de suas pré e pós-condições podemos deduzir ains que serão necessárias as operações de teste de fila cheia, teste de fila vazia.

Assim como na implementação da pilha precisamos de alguma forma de identificar o topo, na fila iremos necessitar de alguma maneira de identificar o seu inicio e seu o fim. ESTADO 0 0 INICIAL 1 2 3 4 5 inicio fim INSERE M1 1 1 M1 1 2 3 4 5 inicio fim INSERE M1 M2 1 2 M2 1 2 3 4 5 inicio fim INSERE M1 M2 M3 1 3 M3 1 2 3 4 5 inicio fim INSERE M1 M2 M3 M4 1 4 M4 1 2 3 4 5 inicio fim INSERE M1 M2 M3 M4 M5 1 5 M5 1 2 3 4 5 inicio fim REMOVE M2 M3 M4 M5 2 5 1 2 3 4 5 inicio fim.. REMOVE M3 M4 M5 3 5 1 2 3 4 5 inicio fim O diagrama acima ilustra uma fila com capacidade para cinco elementos implementada em uma estrutura semelhante a um vetor. O digrama também ilustra a inserção de cinco elementos (M1..M5) e duas operações de remoção. Note que as valores de inicio e fim são usados para armazenar as posições atuais do início e do fim da fila. Inicialmente o valor de inicio está em zero. Podemos usar esta condição detectarmos se a fila está vazia. Quando o elemento M1 é inserido, este é colocado na posição 1 e o inicio e o fim são atualizados, ambos para 1. A medida que outros elementos são inseridos o fim é atualizado. Quando o fim chega a 5, temos que a fila não comporta mais nenhuma inserção, isto é, a fila está cheia. Assim, podemos usar esta condição para detectarmos se a fila.

A medida que as remoções ocorrem o inicio da fila é atualizado, de forma a identificar sempre o elemento a ser removido. Um problema desta implementação é que uma vez que fim atingiu o valor máximo (5 neste caso), não são possíveis mais inserções, mesmo havendo outros espaços. Isto é ruim possui torna a fila muito limitada. Para contarmos este problema veremos duas outras implementações: Remoção com deslocamento e fila circular. Na remoção com deslocamento a medida que os elementos são removidos os elementos remanescentes são deslocados para o inicio do arranjo. INSERE M1 M2 M3 M4 M5 1 5 M5 1 2 3 4 5 inicio fim REMOVE M2 M3 M4 M5 1 4 1 2 3 4 5 Inicio fim.. REMOVE M3 M4 M5 1 3 1 2 3 4 5 Inicio fim INSERE M4 M5 1 2 M5 1 2 3 4 5 Inicio fim REMOVE M5 1 1 1 2 3 4 5 inicio fim.. REMOVE 1 0 1 2 3 4 5 inicio fim Note que, nesta implementação, após a remoção de todos os elementos o valor de inicio permaneceu com 1 e o valor de fim passou a ser zero. Assim a condição de fila vazia não pode ser verificada pelo teste de inicio = 0. Uma possível teste é fim = 0 ou fim menor que inicio. A seguir vamos ver uma implementação em C usando arranjos para esta fila. Posteriormente veremos a implementação utilizando fila circular. Ordenar uma fila utilizando 2 pilhas como variáveis auxiliares. Ao final da ordenação o elemento no inicio da fila deve ser menor que o segundo da fila e assim sucessivamente. A ordenação deve ser feita apenas em termos das operações insere, remove, filavazia, empilha, desempilha e pilhavazia. A função deve seguir a organização a seguir: void ordena_2p (Fila* f){

Pilha p1, p2;.. 2.2.2 Implementação de Filas em arranjos com deslocamento De forma similar a implementação de Pilha iremos definir um módulo em C para implementação da Fila. A seguir temos a definição da interface (arquivo filaecd.h) do TAD Fila. /* * Interface do Tad Fila * Especifica uma pilha para empilhar e desempilhar Elementos definidos como inteiro. * */ #include <stdio.h> #define TRUE 1 #define FALSE 0 #define MAXFILA 10 /* tamanho máximo da fila */ typedef int Elemento; /*Tipo basico a ser enfileirado. Se quiser alterar o tipo, modifique aqui.*/ typedef struct { Elemento itens[maxfila]; /*arranjo para guardar os elementos */ int inicio,fim; /* campos usados para manter o inicio e o fim da fila */ TadFila; /* assinatura das operações todas as operações retornam TRUE em caso de sucesso e * FALSE caso contrario */ int inicializafila(tadfila *); int filavazia(tadfila); int filacheia(tadfila); int inserenafila(tadfila *, Elemento); int removedafila(tadfila *, Elemento *); /* foi adicionada a operação imprimefila que imprime todos os elementos da Fila */ void imprimefila(tadfila); quadro a seguir apresenta o arquivo filaecd.c, contendo a implementação das operações.

/* Implementação das operações do TAD Fila com deslocamento na remoção. */ #include "filaecd.h" /* condição inicial da Fila: inicio == 0 e fim == -1 */ int inicializafila(tadfila *q) { q->inicio = 0; q->fim = -1; return TRUE; /* a condição de Fila Cheia é se o fim atingiu o limite (MAXFILA-1)*/ int filacheia(tadfila q) { return (q.fim == MAXFILA-1); /* a condição de Fila vazia é verificada pelo indice do fim. * Se fim == -1 entao a fila está vazia*/ int filavazia(tadfila q) { return (q.fim==-1); /* a inserção na fila é feita no fim. Como fim é iniciado com -1 este é inicialmente incrementado e depois o elemento é inserido. */ int inserenafila(tadfila *q, int elem) { if (filacheia(*q)== FALSE) { q->fim++; // incrementa o fim q->itens[q->fim] = elem; // insere o elemento no fim da fila return (TRUE); return (FALSE); /* Ao remover um elemento os elementos remanescente na fila são deslocados. O inicio permanece sempre com valor igual a 0. */ int removedafila(tadfila *q, int *elem){ int i; if (filavazia(*q) == FALSE) { *elem = q->itens[q->inicio]; // quarda o elemento i=q->inicio; // usa o i para o deslocamento while (i<q->fim){ q->itens[i] = q->itens[i+1]; i++; q->fim--; return (TRUE); return (FALSE);

O código está comentado e pretende ser auto-explicativo. A ioperação inserenafila insere os elementos passados como parâmetro (elem). Para inserir na fila, inicialmente o valor de fim é incrementado, visto que este foi inicializado com valor 1. Dessa forma a primeira inserção insere na posição 0 do vetor, a segunda na posição 1 e assim sucessivamente. A operação mais complexa é a remoção. Para remover, inicialmente o elemento no inicio da fila é passado por referência por meio do parâmetro (elem *). Posteriomente os elementos remanescentes na Fila são deslocados de um pasição. Dessa forma o elemento do inicio da fila ocupa novamente a posição 0 do vetor. O código a seguir (arquivo principal.c) permite testar a Fila. #include <stdio.h> #include"filaecd.h" void testefilaecd(); void testefilaecd(){ TadFila q; int i; Elemento e; inicializafila(&q); for(i=0;i<10;i++) { inserenafila(&q,i); while(filavazia(q)==false){ if(removedafila(&q,&e)) { printf("%d\n",e); fprintf(stderr,"terminou ok.\n"); int main(){ testefilaecd(); return 0; A função testefilaecd declara uma fila (q), incializa a fila, insere os inteiros de 0 a 9 e depois remove os elementos e os imprime. Note que todo o processamento é feito usando as operações do Tad Fila. Exercício: Implementar as operações imprimir Fila para o TAD Fila implementado.