341sicos com o microsoft visio...

Criando Fluxogramas

com o Microsoft Office

Visio 2003

Roberto Scalco

2003 / 2006

Criando Fluxogramas com o Microsoft Office Visio 2003 - 3

Índice

LISTA DE FIGURAS............................................................................................................................................ 4

INTRODUÇÃO .................................................................................................................................................... 6

CAPÍTULO 1 – O AMBIENTE VISIO ................................................................................................................ 7

1. INICIANDO O APLICATIVO.......................................................................................................................................................7 2. O AMBIENTE DE TRABALHO ...................................................................................................................................................9

CAPÍTULO 2 – A LÓGICA EM CAIXINHAS.................................................................................................... 15

1. INTRODUÇÃO...........................................................................................................................................................................15 2. ELEMENTOS AUXILIARES.......................................................................................................................................................15 3. UM PROGRAMA SIMPLES – ESTRUTURAS SEQÜENCIAIS....................................................................................................18 4. ESTRUTURAS CONDICIONAIS ................................................................................................................................................19 5. ESTRUTURAS REPETITIVAS ....................................................................................................................................................23 6. SUB-ROTINAS ...........................................................................................................................................................................26 7. ARQUIVOS DE ACESSO ALEATÓRIO......................................................................................................................................29

CAPÍTULO 3 – EXEMPLOS EM PASCAL E DELPHI.....................................................................................33

1. PASCAL ......................................................................................................................................................................................33 2. DELPHI......................................................................................................................................................................................43

REFERÊNCIAS...................................................................................................................................................52


Lista de Figuras FIGURA 1.1: ÍCONE DO MICROSOFT OFFICE VISIO 2003...................................................................................................................7 FIGURA 1.2: INTERFACE PARA ESCOLHA DO MODELO DO DESENHO..............................................................................................7 FIGURA 1.3: ÍCONE MODELO FLUXOGRAMA BÁSICO. ........................................................................................................................8 FIGURA 1.4: AMBIENTE DE TRABALHO DO MICROSOFT OFFICE VISIO 2003. ...............................................................................8 FIGURA 1.5: BARRA PADRÃO. ..................................................................................................................................................................9 FIGURA 1.6: ÍCONE DO MICROSOFT OFFICE VISIO 2003...................................................................................................................9 FIGURA 1.7: JANELA DE CONFIGURAÇÃO DE LINHAS. ......................................................................................................................10 FIGURA 1.8: BARRA DE FORMAS. ..........................................................................................................................................................10 FIGURA 1.9: ELEMENTO SELECIONADO. ............................................................................................................................................11 FIGURA 1.10: MOVIMENTANDO UM OBJETO. .....................................................................................................................................11 FIGURA 1.11: MUDANÇA DE ESCALA....................................................................................................................................................11 FIGURA 1.12: ROTAÇÃO DE UM OBJETO. .............................................................................................................................................12 FIGURA 1.13: SELEÇÃO DE VÁRIOS OBJETOS. .....................................................................................................................................12 FIGURA 1.14: MENU POPUP PARA DEFINIÇÃO DAS PROPRIEDADES DE UM OBJETO....................................................................13 FIGURA 1.15: ITEM FORMA DO MENU POPUP DOS OBJETOS ............................................................................................................13 FIGURA 1.16: MENU POPUP DE GERENCIAMENTO DE PÁGINAS .....................................................................................................13 FIGURA 1.17: JANELA CONFIGURAR PÁGINA. ....................................................................................................................................14 FIGURA 2.1: SÍMBOLO DO TERMINADOR. ............................................................................................................................................15 FIGURA 2.2: EXEMPLO DOS TERMINADORES INÍCIO E FIM. ............................................................................................................15 FIGURA 2.3: SÍMBOLO DO CONECTOR DINÂMICO. ............................................................................................................................16 FIGURA 2.4: FERRAMENTA CONECTOR. ..............................................................................................................................................16 FIGURA 2.5: PASSOS PARA A CRIAÇÃO DO FLUXO DE DADOS UTILIZANDO A FERRAMENTA CONECTOR. .............................16 FIGURA 2.6: DEFININDO O FLUXO DE DADOS UTILIZANDO UM PONTO DE CONEXÃO.............................................................16 FIGURA 2.7: SÍMBOLO DA ANOTAÇÃO. ................................................................................................................................................17 FIGURA 2.8: COMENTÁRIO DE UMA INSTRUÇÃO. ..............................................................................................................................17 FIGURA 2.9: COMENTÁRIO DE UM BLOCO. .........................................................................................................................................17 FIGURA 2.10: SÍMBOLO DO CONECTOR. ..............................................................................................................................................17 FIGURA 2.11: EXEMPLO DE CONECTOR DE FLUXOS DE DADOS. ....................................................................................................18 FIGURA 2.12: EXEMPLO DE DESCONTINUIDADE DO FLUXO DE DADOS. .....................................................................................18 FIGURA 2.13: SÍMBOLO DA ENTRADA MANUAL DE DADOS..............................................................................................................18 FIGURA 2.14: SÍMBOLO DE PROCESSO..................................................................................................................................................19 FIGURA 2.15: SÍMBOLO DA EXIBIÇÃO. .................................................................................................................................................19 FIGURA 2.16: SOMA DE DOIS VALORES. ...............................................................................................................................................19 FIGURA 2.17: SÍMBOLO DA DECISÃO. ...................................................................................................................................................19 FIGURA 2.18: FERRAMENTA TEXTO.....................................................................................................................................................20 FIGURA 2.19: ESTRUTURA CONDICIONAL SIMPLES............................................................................................................................20 FIGURA 2.20: ESTRUTURA CONDICIONAL COMPOSTA. .....................................................................................................................20 FIGURA 2.21: ESTRUTURA CONDICIONAL CASO.................................................................................................................................21 FIGURA 2.22: DISTRIBUIÇÃO DOS OBJETOS. .......................................................................................................................................21 FIGURA 2.23: CRIAÇÃO DO CAMINHO MAIOR.....................................................................................................................................22 FIGURA 2.24: CRIAÇÃO DE UMA LINHA HORIZONTAL. .....................................................................................................................22 FIGURA 2.25: POSICIONAMENTO DA EXTREMIDADE FINAL DO FLUXO DE DADOS. ...................................................................22 FIGURA 2.26: AJUSTE DA EXTREMIDADE INICIAL DO FLUXO DE DADOS......................................................................................22 FIGURA 2.27: CAMINHO VERDADEIRO DA ESTRUTURA CONDICIONAL CASO..............................................................................23 FIGURA 2.28: SÍMBOLO DO LAÇO DE REPETIÇÃO. .............................................................................................................................23 FIGURA 2.29: ESTRUTURA DE UM LAÇO DE REPETIÇÃO. ..................................................................................................................23 FIGURA 2.30: ESTRUTURA REPITA-ATÉ COM SÍMBOLO DE DECISÃO.............................................................................................24 FIGURA 2.31: ESTRUTURA REPITA-ATÉ COM ELEMENTOS LIMITADORES. ...................................................................................24 FIGURA 2.32: ESTRUTURA ENQUANTO-FAÇA COM SÍMBOLO DE DECISÃO. .................................................................................25 FIGURA 2.33: ESTRUTURA ENQUANTO-FAÇA COM ELEMENTOS LIMITADORES..........................................................................25 FIGURA 2.34: ESTRUTURA PARA-ATÉ-FAÇA COM SÍMBOLO DE DECISÃO.....................................................................................25 FIGURA 2.35: ESTRUTURA PARA-ATÉ-FAÇA COM ELEMENTOS LIMITADORES. ...........................................................................26 FIGURA 2.36: SÍMBOLO DA SUB-ROTINA..............................................................................................................................................26 FIGURA 2.37: ESTRUTURA DE UMA SUB-ROTINA................................................................................................................................27 FIGURA 2.38: CHAMADA DE UMA SUB-ROTINA. .................................................................................................................................27 FIGURA 2.39: CABEÇALHO DE UMA SUB-ROTINA...............................................................................................................................27


FIGURA 2.40: ESTRUTURA DE UM PROCEDIMENTO...........................................................................................................................28 FIGURA 2.41: CHAMADA DE UM PROCEDIMENTO. ............................................................................................................................28 FIGURA 2.42: ESTRUTURA DE UMA FUNÇÃO.......................................................................................................................................28 FIGURA 2.43: CHAMADA DE UMA FUNÇÃO EM UM PROCESSO.........................................................................................................29 FIGURA 2.44: CHAMADA DE UMA FUNÇÃO EM UMA COMPARAÇÃO. ..............................................................................................29 FIGURA 2.45: SÍMBOLO DE ACESSO DIRETO AOS DADOS DE UM ARQUIVO...................................................................................30 FIGURA 2.46: CRIAÇÃO DE UM ARQUIVO. ...........................................................................................................................................30 FIGURA 2.47: ABERTURA DE UM ARQUIVO. ........................................................................................................................................30 FIGURA 2.48: FECHAR UM ARQUIVO. ...................................................................................................................................................30 FIGURA 2.49: GRAVAR UM REGISTRO EM UM ARQUIVO....................................................................................................................31 FIGURA 2.50: GRAVAR UM CAMPO DE UM REGISTRO EM UM ARQUIVO.........................................................................................31 FIGURA 2.51: LER UM REGISTRO DE UM ARQUIVO. ...........................................................................................................................31 FIGURA 2.52: LER UM CAMPO DE UM REGISTRO DE UM ARQUIVO. ................................................................................................31 FIGURA 2.53: ASSOCIAR OS ARQUIVOS LÓGICO E FÍSICO. ................................................................................................................32 FIGURA 2.54: DEFINIR A POSIÇÃO DO PONTEIRO EM UM ARQUIVO. .............................................................................................32 FIGURA 2.55: OBTER A POSIÇÃO ATUAL DO PONTEIRO EM UM ARQUIVO. ...................................................................................32 FIGURA 2.56: OBTER A QUANTIDADE DE REGISTROS DE UM ARQUIVO........................................................................................32 FIGURA 3.1: CONVERSÃO DE TEMPERATURA. ....................................................................................................................................33 FIGURA 3.2: CÁLCULO DAS RAÍZES DA EQUAÇÃO DO SEGUNDO GRAU. .......................................................................................34 FIGURA 3.3: CALCULADORA COM QUATRO OPERAÇÕES. .................................................................................................................36 FIGURA 3.4: CÁLCULOS VETORIAIS.......................................................................................................................................................38 FIGURA 3.5: CÁLCULO DO DETERMINANTE. ......................................................................................................................................40 FIGURA 3.6: PROGRAMA PRINCIPAL. ....................................................................................................................................................41 FIGURA 3.7: LEITURA DE VALORES. .....................................................................................................................................................44 FIGURA 3.8: EXIBIÇÃO DE VALORES. ...................................................................................................................................................44 FIGURA 3.9: INTERFACE DO APLICATIVO............................................................................................................................................45 FIGURA 3.10: FLUXOGRAMA DO BOTÃO MONTAR TABELA. ...........................................................................................................45 FIGURA 3.11: INTERFACE DO APLICATIVO..........................................................................................................................................47 FIGURA 3.12: FLUXOGRAMAS DO APLICATIVO...................................................................................................................................48


Introdução Em diversas áreas da Engenharia a representação gráfica de um modelo é um importante canal de comunicação entre os profissionais. Para garantir que não haja falhas na comunicação, a linguagem deve ser bem detalhada e sua estrutura deve representar com fidelidade as informações do modelo.

Diversas áreas do conhecimento possuem um conjunto de símbolos e regras que definem uma linguagem gráfica de comunicação. São exemplos as vistas ortográficas, as perspectivas isométricas, as plantas, as curvas de nível e as representações de conjuntos. Todos estes exemplos trazem informações sobre as dimensões, formas, encaixes e detalhes de um objeto real, sob diferentes formas de representação.

Além destas representações, existem os diagramas que também trazem informações que não estão associadas à forma do objeto. Estes diagramas são representações simplificadas, mas ricas em informações. Os diagramas de fluxo de dados, as redes PERT, os grafos e os fluxogramas são exemplos de diagramas.

O Microsoft Office Visio 2003 permite ao usuário criar diversos tipos de diagramas, como os citados. Trata-se de uma ferramenta simples de utilizar, uma vez que seus principais recursos também estão presentes em diversos outros aplicativos para o Microsoft Windows.

O enfoque deste trabalho é a confecção de algoritmos sob a forma gráfica: os fluxogramas. Estes diagramas expressam os passos bem definidos e finitos que um computador deve executar, com intuito de realizar uma tarefa previamente definida.

Por se tratar de uma linguagem de comunicação entre os profissionais da área da Computação, o fluxograma possui um conjunto de símbolos e regras bem definidas para evitar dúvidas por parte dos seus usuários. Este conjunto de regras foi definido pela International Organization for Standardization em 1985 e é denominado ISO 5807: information processing – documentation symbols and conventions for data, program and system flowcharts, program network charts and system resources charts.

Tais símbolos podem ser encontrados no Microsoft Office Visio 2003, inclusive pelo nome do elemento definido pela norma.

Os fluxogramas ganharam destaque na programação procedural por duas razões: a facilidade em expressar “a idéia” de como funciona o algoritmo que se deseja desenvolver e documentar o projeto, permitindo com que outras pessoas possam entender como o problema foi resolvido sem ter que verificar o código-fonte.

Além disso, o fluxograma não está associado a nenhuma linguagem de programação. O mesmo fluxograma pode transcrito para a linguagem Pascal, C, Java, Basic, etc., tornando-se uma linguagem entre programadores que utilizam linguagens de programação totalmente diferentes.

A Computação possui diversos tipos de diagramas, entretanto, aos que iniciam na programação, o fluxograma representa uma linguagem simples e permite a fácil tradução para linguagens estruturadas procedurais, como é o caso da linguagem Pascal.


Capítulo 1 – O Ambiente Visio

1. Iniciando o aplicativo

1.1. Para abrir o programa...

O Microsoft Office Visio 2003 pode ser executado quando o usuário clica sobre o seu ícone, pertencente ao menu Microsoft Office, acessível pelo item Todos os programas (utilizando o Windows XP) do menu Iniciar. A figura 1.1 mostra o ícone do aplicativo.

Figura 1.1: Ícone do Microsoft Office Visio 2003.

1.2. Escolha do modelo

Uma vez aberto, o aplicativo solicita que o usuário faça uma escolha sobre o tipo de desenho ou diagrama que será confeccionado, como mostra a figura 1.2:

Figura 1.2: Interface para escolha do modelo do desenho.


O primeiro passo consiste em definir a qual categoria o diagrama que será criado pertence. Dentre as categorias, destacam-se os diagramas de processos, organogramas, redes, mapas 3d e banco de dados. O foco deste trabalho serão os fluxogramas, permitindo ao usuário criar algoritmos sob a forma gráfica.

Para abrir o ambiente de trabalho com as ferramentas de fluxogramas, deve-se selecionar a categoria Fluxograma. Dentre os cinco modelos contidos nesta categoria, deve-se clicar sobre o ícone do Fluxograma Básico, mostrado na figura 1.3:

Figura 1.3: Ícone modelo Fluxograma Básico. Desta maneira, o ambiente de trabalho está configurado e pronto para que o usuário possa

confeccionar, em uma ou mais páginas, um fluxograma completo, com suas estruturas condicionais e repetitivas, além da criação de sub-rotinas.

Figura 1.4: Ambiente de trabalho do Microsoft Office Visio 2003.


2. O ambiente de trabalho 2.1. Manipulação básica de arquivos

A manipulação básica de arquivos de documentos do Microsoft Office Visio 2003 é realizada de maneira semelhante a outros aplicativos comerciais. As principais instruções são: Novo, Abrir e Salvar.

Estas instruções podem ser encontradas no menu Arquivo ou na barra Padrão, apresentada na figura 1.5:

Figura 1.5: Barra Padrão. Como pode ser observado, os três primeiros ícones representam as ações Novo, Abrir e Salvar,

respectivamente. Os arquivos criados e manipulados pelo Microsoft Office Visio 2003 possuem a extensão VSD (Visio Diagram).

Os elementos gerados pelo Microsoft Office Visio 2003 podem ser facilmente transportados para outros aplicativos. Para tal, devem-se selecionar os elementos com auxílio do mouse e clicar sobre o botão Copiar. Depois, em outro aplicativo, como por exemplo o Microsoft Office Word, deve-se clicar sobre o botão Colar.

Desta maneira, a documentação de um aplicativo ou projeto pode ser facilmente editorada, associando os recursos de um editor de texto e os diagramas confeccionados no Microsoft Office Visio 2003.

2.2. Manipulação e configuração de elementos

O ambiente de trabalho do Microsoft Office Visio 2003 é composto pelo menu, pelas barras de ferramentas, pela barra de formas e por uma página para o desenho. Alguns destes itens recebem o destaque a seguir:

Barra Formatação

A barra Formatação permite ao usuário definir as propriedades visuais de um ou mais elementos selecionados, como a sua cor, espessura de linha, formatação do texto, entre outros. A figura 1.6 mostra esta barra:

Figura 1.6: Ícone do Microsoft Office Visio 2003.

Uma vez que os elementos estejam selecionados, o usuário deve clicar sobre o ícone desejado, como Negrito, Sublinhado ou Centralizar. Os ícones que possuem uma seta do lado direito apresentando ao usuário uma gama de opções, como cores, espessuras, extremidades de linhas, entre outros. Clicando sobre a seta, as opções são apresentadas, bastando ao usuário clicar sobre a configuração desejada.

Caso nenhuma opção atenda às necessidades do usuário, existe uma opção que abre uma janela com mais opções. As janelas de configuração estão divididas em duas categorias: cores, referentes à


formatação da cor da fonte, da linha e do preenchimento e linhas, permitindo configurar a espessura, tipo e setas.

Figura 1.7: Janela de configuração de linhas.

É recomendado que todo o fluxograma seja criado inicialmente e somente depois selecionar todos os objetos e aplicar as configurações desejadas.

Barra Formas

A barra Formas é a principal fonte de recursos durante a confecção dos diagramas. Pode conter abas com diversos modelos distintos. A figura 1.8 mostra o exemplo de uma barra de Formas contendo as abas Formas de Seta, Planos de Fundo, Formas de Fluxograma Básico e Bordas e Títulos. Ao clicar sobre o nome do modelo, seu conteúdo é exibido. O exemplo a seguir mostra o conteúdo da aba com os modelos Formas de Fluxograma Básico.

Figura 1.8: Barra de Formas.


Caso a barra Formas seja acidentalmente fechada, ou o usuário desejar abrir um outro modelo, deve-se clicar sobre o item Arquivo do menu. Dentre as opções, deve-se posicionar o cursor do mouse sobre o item Formas ►. A situação apresentada pelo aplicativo é semelhante à inicial, ou seja, o usuário deve escolher a categoria e o modelo que será adicionado na barra Formas.

Para inserir elementos no documento, basta clicar sobre o ícone do elemento desejado da barra Formas e arrastá-lo para o interior da página que representa o documento.

Uma vez que o elemento esteja na página, o usuário pode facilmente manipulá-lo. Para tal, o primeiro passo consiste em selecionar os elementos. Caso apenas um objeto deva ser selecionado, basta clicar sobre ele utilizando o botão esquerdo do mouse. Ao clicar na página, a seleção é removida.

Figura 1.9: Elemento Selecionado. Para indicar que um o objetos está selecionado, o Microsoft Office Visio 2003 exibe oito alças de

seleção, representados por pequenos quadrados verdes. Além disso, acima do objeto a alça de rotação é exibida sob a forma de um círculo verde.

As transformações lineares que o Microsoft Office Visio 2003 permite aplicar sobre os elementos são divididas em três categorias:

• Translação: Para movimentar um objeto, deve-se clicar sobre uma região pertencente ao interior

do objeto selecionado e depois movimentar o cursor do mouse livremente pela página. Ao soltar o botão do mouse, o elemento será fixo no novo local. Deve-se notar que o símbolo de movimentação é acrescido ao cursor do mouse.

Figura 1.10: Movimentando um objeto.

• Mudança de Escala: Para modificar as dimensões de um objeto, deve-se clicar sobre uma das alças de seleção. Ao movimentar o cursor do mouse, as dimensões do objeto são alteradas. Quando o botão do mouse é solto, as dimensões do elemento serão definidas. Deve-se notar que o símbolo de movimentação substitui o cursor padrão do mouse.

Figura 1.11: Mudança de escala.


As alças horizontais permitem a mudança de escala na horizontal. De modo semelhante, as alças verticais permitem a mudança de escala na vertical. As alças localizadas nos vértices da seleção permitem a mudança de escala em ambas as direções.

• Rotação: Para rotacionar um objeto, deve-se clicar sobre a alça de rotação de um objeto selecionado e movimentar o cursor do mouse. Com o objeto na posição desejada, o botão do mouse deve ser solto para que o elemento permaneça na posição estipulada.

Figura 1.12: Rotação de um objeto. Quando o usuário clica sobre a alça de rotação, o centro de rotação é marcado por um pino. Este centro de rotação pode ser movido quando o usuário clicar sobre ele e movimentar o cursor do mouse. Para selecionar mais do que um objeto, deve-se criar uma janela que contenha os elementos.

Deve-se notar que apenas os objetos que estejam inteiramente no interior da janela serão selecionados.

O exemplo da figura 1.13 mostra uma janela de seleção que contém três blocos, três conectores e apenas uma parte do bloco inferior. Quando o usuário soltar o botão do mouse, desde que mantida as dimensões da janela, apenas os três blocos superiores e os conectores serão selecionados, ignorando o bloco inferior.

Figura 1.13: Seleção de vários objetos. As transformações lineares aplicadas ao conjunto de objetos selecionados são executadas de

maneira equivalente aos objetos selecionados individualmente. Além das transformações lineares, é possível inserir textos no interior das formas. Para tal, deve-

se dar um duplo clique sobre o objeto. O cursor de edição de texto será exibido e todas as funcionalidades referentes à formatação de tipo, cor e tamanho da fonte poderão ser aplicadas ao texto selecionado.


Menu popup de propriedades de objetos

É possível configurar diversas propriedades dos objetos utilizando o menu popup que se torna acessível quando o usuário clica com o botão direito do mouse sobre um ou mais objetos selecionados.

Figura 1.14: Menu popup para definição das propriedades de um objeto. Além de permitir que os elementos selecionados sejam copiados, recortados ou colados, também

pode-se definir as características de cores, tipos de linha e da fonte nos subitens do item Formatar ►. O item Forma ► contém alguns casos de transformações lineares que são comumente utilizados,

como a reflexão em relação ao eixo vertical ou horizontal, além da rotação dos objetos, em seu centro de rotação, de um ângulo de 90° para a direita ou esquerda. A figura 1.15 mostra os itens disponíveis:

Figura 1.15: Item Forma do menu popup dos objetos Criando páginas no documento

Quando um documento é criado, apenas uma página está disponível para a confecção de diagramas. Caso o usuário deseje criar mais páginas em um mesmo arquivo, deve-se clicar com o botão direito do mouse sobre a aba inferior, contendo o nome da página, como mostra a figura 1.16:

Figura 1.16: Menu popup de gerenciamento de páginas


Um menu popup será exibido contendo algumas opções para o gerenciamento das páginas. Basta clicar sobre o item Inserir Página ………… para abrir a janela de Configurar página.

Figura 1.17: Janela Configurar página. Existem diversas propriedade que o usuário pode alterar distribuídas entre as abas da janela

Configurar página. Após a definição das propriedades, se houverem, o usuário deve clicar sobre o botão OK. Desta forma, uma nova página será exibida e a navegação entre as páginas existentes se dá pelas abas contendo o nome de cada página, na parte inferior do ambiente de trabalho.


Capítulo 2 – A Lógica em Caixinhas

1. Introdução

A necessidade da criação de fluxogramas se dá devido à facilidade de representar uma idéia sob a forma gráfica, além de permitir a padronização de uma linguagem de comunicação entre profissionais da área da Computação.

Como toda linguagem, a representação gráfica de um algoritmo segue regras para garantir o entendimento de todos aqueles que leiam um fluxograma. Além disso, o fluxograma representa um passo intermediário do desenvolvimento de um aplicativo, ou seja, o fluxograma deve conter instruções e prever situações, simulando a sua execução por um computador.

As seções a seguir apresentam os símbolos utilizados para cada situação, além de referenciar qual elemento da barra Formas o usuário deve utilizar, lembrando que para utilizar um elemento, deve-se arrastar o objeto da barra Formas para página do projeto.

2. Elementos auxiliares

Em um fluxograma, existem alguns elementos fundamentais à construção do algoritmo, mas que não estão ligados a nenhuma estrutura de programação. Podem delimitar o algoritmo, ou simplesmente indicar que existe mais alguma coisa em outra página.

2.1. Terminais

Todo algoritmo possui um início e um fim. Os terminais ou terminadores são os responsáveis pela delimitação de um algoritmo, seja o programa principal ou uma sub-rotina.

Figura 2.1: Símbolo do terminador. Em seu conteúdo, deve aparecer a palavra “Início” ou “Fim”, indicando a sua função. Para

adicionar um texto, deve-se dar um duplo clique sobre o objeto.

Figura 2.2: Exemplo dos terminadores Início e Fim. 2.2. Fluxo de dados

O fluxo de dados indica o caminho, desde o início até o fim, que as informações são processadas. É representado por uma linha ou por um conjunto contínuo de linhas cujos ângulos formados por suas


componentes são 90°. No final da linha ou do conjunto de linhas deve-se adicionar uma seta, indicando o sentido percorrido.

O fluxo de dados pode ser criado por meio de duas ferramentas, sendo que a primeira está na barra Formas e é denominada Conector Dinâmico.

Figura 2.3: Símbolo do conector dinâmico. Uma vez adicionado, o usuário deve posicionar as suas extremidades com auxílio do mouse. O fluxo de dados também pode ser criado por meio da Ferramenta Conector da barra Padrão.

Figura 2.4: Ferramenta Conector. Para criar o fluxo de dados, deve-se clicar sobre a página do projeto e mover o cursor do mouse.

Quando o fluxo de dados estiver com as características que o usuário desejar, deve-se soltar o botão do mouse, criando o elemento.

Passo 1 – Primeiro ponto

Passo 2 – Mover o cursor

Passo 3 – Soltar o botão

Figura 2.5: Passos para a criação do fluxo de dados utilizando a Ferramenta Conector. Estes dois pontos que definem o fluxo de dados podem ser definidos em função de objetos

pertencentes à página do projeto. Desta maneira, ao aproximar o cursor do mouse de um ponto de conexão (indicado por pequenos “x” azuis dos objetos) este será destacado com um quadrado vermelho. Com o foco no ponto de conexão, o usuário tem a certeza de que o fluxo de dados que será desenhado estará ligado ao objeto.

Figura 2.6: Definindo o fluxo de dados utilizando um ponto de conexão.

2.3. Comentários Durante a elaboração de um fluxograma ou até mesmo de um programa em uma linguagem qualquer, é conveniente criar comentários ou anotações sobre uma determinada instrução ou referente a um bloco de instruções.


Figura 2.7: Símbolo da anotação. Uma vez criado, o elemento pode ser movido livremente e seu extensor deve ser movido para as

proximidades do elemento que será comentado.

Figura 2.8: Comentário de uma instrução. Para definir o texto, deve-se dar um duplo clique sobre o objeto. Também é possível criar comentários referentes a um bloco de instruções. Para tal, deve-se criar

uma caixa com linhas tracejadas e fazer o comentário sobre esta caixa.

Figura 2.9: Comentário de um bloco. Para garantir o efeito apresentado, o valor Sem preenchimento deve ser o parâmetro da

ferramenta Cor do preenchimento (cor). 2.4. Conector

Os conectores são utilizados para unir dois ou mais fluxos de dados que chegam a um determinado ponto e para indicar uma interrupção ou continuação de um fluxo de dados.

Figura 2.10: Símbolo do conector. Quando utilizado para unir as linhas do fluxo de dados o conector deve ser pequeno, sem

atrapalhar a leitura do fluxograma. O exemplo a seguir mostra o uso de um conector de fluxos de dados dos caminhos Verdadeiro e Falso de uma estrutura condicional composta.


A mod 2 = 0

‘Número é par’‘Número é ímpar’

TrueFalse

Figura 2.11: Exemplo de conector de fluxos de dados. A outra aplicação é utilizada quando o fluxograma se estende além do espaço da página. A

descontinuidade do fluxograma deve ser feita utilizando dois conectores com a mesma identificação. Caso haja mais descontinuidades, outro par de conectores deve ser utilizado, tomando o cuidado para que o identificador do par seja exclusivo.

Estes identificadores podem ser letras, números ou palavras escritas no interior do conector. Para escrever, deve-se dar um duplo clique sobre o conector. Como o conteúdo do conector deve possuir um identificador, o seu tamanho é equivalente dos demais objetos do fluxograma. O exemplo a seguir mostra a descontinuidade de um fluxo de dados.

Figura 2.12: Exemplo de descontinuidade do fluxo de dados. 2.5. Atribuição

Existe um importante símbolo em um fluxograma que não está nas barras de ferramentas e menus do Microsoft Office Visio 2003, a seta de atribuição.

Sempre que o resultado de um cálculo for armazenado em uma variável, deve-se utilizar a atribuição. Não existe uma regra bem definida para qual seta utilizar. A sugestão apresentada consiste em utilizar o símbolo ¬ (normalmente presente na tecla 6). A propriedade fonte deste símbolo deve ser ajustada para Symbol, resultando no símbolo: ←.

3. Um programa simples – Estruturas seqüenciais Sabe-se que um algoritmo pode ser elaborado a partir de três estruturas: seqüenciais, condicionais e repetitivas. As entradas de dados, os cálculos realizados por processos e as exibições de resultados são exemplos de instruções dispostas seqüencialmente.

A entrada manual de dados é representada por um trapézio. A origem do símbolo vem da representação simplificada da vista lateral de um teclado. Este símbolo deve conter uma lista de variáveis que serão digitadas pelo usuário, sendo os seus elementos separados por vírgula.

Figura 2.13: Símbolo da entrada manual de dados.


O retângulo representa um símbolo de uma atividade qualquer realizada pelo processador, ou seja, é utilizado para representar instruções ou situações não previstas para os demais símbolos da norma ISO 5807.

Figura 2.14: Símbolo de processo. O seu uso mais comum é a realização de cálculos. Entretanto, um conjunto de regras é aplicado

às expressões escritas em seu interior: • os cálculos devem ser escritos sob a forma horizontal; • para agrupar um trecho de uma expressão devem ser utilizados apenas os parênteses; • os cálculos são executados em dois instantes de tempo diferentes. Para armazenar os valores

calculados (lado direito da expressão) em uma variável (lado esquerdo da expressão), deve-se utilizar o símbolo de atribuição (←).

A exibição dos resultados deve ser realizada após a determinação de um resultado parcial ou

final. A origem do símbolo vem da representação simplificada da vista lateral de um monitor. Este símbolo deve conter uma lista de variáveis separadas por vírgulas que serão exibidas na tela.

Figura 2.15: Símbolo da exibição. O exemplo a seguir mostra um fluxograma para o cálculo e exibição da soma de dois valores

informados pelo usuário, via teclado:

Figura 2.16: Soma de dois valores. 4. Estruturas condicionais

Um algoritmo deve prever todas as situações possíveis para evitar que o computador apresente um erro quando executá-lo. A representação gráfica da tomada de decisões é um losango e em seu interior deve existir uma expressão compatível com o tipo da estrutura condicional utilizada.

Figura 2.17: Símbolo da decisão.


A decisão possui uma entrada do fluxo de dados e duas saídas, uma Verdadeira e outra Falsa. A estrutura condicional caso faz ramificações do caminho Verdadeiro. Estes caminhos devem ser identificados por um texto que representa qual é o resultado da expressão da estrutura de decisão.

Para criar elementos textuais isolados dos símbolos, pode-se utilizar a Ferramenta Texto, pertencente à barra Padrão.

Figura 2.18: Ferramenta Texto. Ao selecionar a Ferramenta Texto, o usuário deve clicar sobre a página. Uma janela de edição

de texto será aberta, permitindo que o usuário digite e formate um texto, de acordo com suas necessidades. A figura 2.19 mostra o exemplo de duas caixas de texto com os valores True e False.

Por se tratar de uma estrutura bem definida, os caminhos da estrutura condicional devem se encontrar para que esta seja encerrada. Não é permitida a entrada de um fluxo de dados externo nos caminhos, nem a derivação do fluxo de dados para fora da estrutura sem passar pelo conector final.

Existem três tipos de estruturas de decisão: simples, composta e caso, descritas a seguir: 4.1. Simples

As estruturas condicionais simples são caracterizadas pela realização de tarefas apenas no caminho Verdadeiro. Embora o caminho Falso não possua nenhuma instrução, o fluxo de dados deve ser representado, ligando o símbolo de decisão ao ponto de término da estrutura.

A condição é representada por uma expressão lógica, ou seja, o seu resultado deve ser o valor True ou o valor False.

Figura 2.19: Estrutura condicional simples. Como pode ser observado, para criar uma estrutura condicional simples, é necessário de um

elemento de decisão, duas caixas de texto e um conector. O bloco de instruções representa um conjunto de estruturas pertinentes à resolução de cada problema. Lembre-se de ligar os elementos.

4.2. Compostas

As estruturas condicionais compostas possuem instruções em ambos os caminhos, o Verdadeiro e o Falso. Semelhante à estrutura condicional simples, a condição também é representada por uma expressão lógica.

Figura 2.20: Estrutura condicional composta.


Como pode ser observado, para criar uma estrutura condicional composta, é necessário um elemento de decisão, duas caixas de texto e um conector. Os blocos de instruções dos caminhos podem possuir qualquer elemento, pois representam parte do algoritmo exposto pelo problema.

4.3. Caso

A estrutura condicional caso é caracterizada pela ramificação do caminho Verdadeiro. Desta maneira, a sua condição não é uma expressão lógica, mas uma expressão ordinal (um valor inteiro ou um caractere).

Uma vez que existem vários caminhos Verdadeiros, estes devem ser identificados por uma caixa de texto com o resultado da expressão. Deve-se lembrar que os caracteres são diferenciados dos valores inteiros pela presença de aspas delimitando-os.

O caminho Falso pode ou não conter instruções, mas independente do seu conteúdo, deve ser representado e identificado.

Falsecondição

Instruções T1

Instruções T2

Instruções Tn

Instruções F

Valor 1

Valor 2

Valor n

Figura 2.21: Estrutura condicional caso. A estrutura condicional caso possui um elemento de decisão, uma caixa de texto para o caminho

Falso, N caixas de texto para o caminho Verdadeiro, além dos conectores. Um problema que ocorre é a construção da ramificação do fluxo de dados do caminho

Verdadeiro. Não existe uma ferramenta para a construção direta de um fluxo de dados ramificado como o apresentado no exemplo da figura 2.21. Para tal, deve-se utilizar um conjunto de elementos, como mostram os passos a seguir:

1. Distribuir os símbolos de instruções em suas respectivas posições;

Figura 2.22: Distribuição dos objetos.

2. Ligar a decisão ao elemento do último caminho;


Figura 2.23: Criação do caminho maior.

3. Criar um fluxo de dado horizontal. Este elemento não deve estar ligado a nenhum objeto.

Figura 2.24: Criação de uma linha horizontal.

4. Mover o fluxo de dados horizontal de forma que a ponta da seta coincida com o objeto de um dos caminhos. Para assegurar que o fluxo de dados estará associado ao objeto, deve-se mover objeto até um dos pontos de conexão. A exibição de um quadrado vermelho indica que a associação será um sucesso;

Figura 2.25: Posicionamento da extremidade final do fluxo de dados.

5. Clicar sobre a extremidade solta do fluxo de dados e, com a tecla �� Shift pressionada, movimentar o cursor do mouse. O uso da tecla �� Shift garante que pequenas variações na movimentação do cursor do mouse não alterem o ângulo do fluxo de dados.

Figura 2.26: Ajuste da extremidade inicial do fluxo de dados.


6. Quando a extremidade livre do fluxo de dados estiver sobre a linha principal do caminho Verdadeiro, soltar o botão do mouse e depois a tecla�� Shift. Estes passos devem ser repetidos para os demais elementos do caminho Verdadeiro.

Figura 2.27: Caminho Verdadeiro da estrutura condicional caso.

5. Estruturas repetitivas Em algumas situações, um determinado trecho de um algoritmo deve ser repetido várias vezes. Entretanto, a solução do algoritmo pode se tornar inviável ou até mesmo impossível de se realizar. Isto ocorre nas situações onde o número de repetições é alto ou indeterminado.

Para resolver tal situação, as estruturas repetitivas foram criadas, permitindo executar várias vezes as instruções delimitadas pelo laço de repetição.

É possível representar uma estrutura de repetição utilizando dois conjuntos de símbolos diferentes. A primeira maneira utiliza o símbolo de decisão, apresentado no item 4 – Estruturas condicionais, enquanto que a segunda utiliza um símbolo próprio para o laço de repetição, apresentado na figura 2.28.

Figura 2.28: Símbolo do laço de repetição. Estes símbolos são utilizados para limitar as instruções de um laço de repetição. O símbolo que

representa o final da estrutura repetitiva deve ser espelhado em relação ao eixo horizontal, como apresentado no item Menu popup de propriedades de objetos do capítulo 2. Além disso, os dois objetos devem possuir a mesma largura e estarem alinhados.

Figura 2.29: Estrutura de um laço de repetição. O conjunto de elementos utilizados para a criação de uma estrutura repetitiva com objetos

limitando as instruções que serão repetidas é o mesmo para as três estruturas de repetição: o Repita-Até, o Enquanto-Faça e o Para-Até-Faça. O conteúdo de cada elemento limitante é definido pela estrutura de repetição utilizada.


Deve-se notar que não existe nenhuma indicação sobre qual é o resultado da condição (Verdadeiro ou Falso) que sai do laço ou que retorna para uma nova execução. Além disso, o caminho de retorno não deve ser representado.

Desta forma, embora mais simples de utilizar, é recomendado que um programador inicie seus estudos de algoritmos utilizando as repetições escritas com o símbolo de decisão, uma vez que existem as indicações sobre qual é o caminho que retorna e o que sai da estrutura. Com um pouco de prática e conhecendo bem as características de cada estrutura de repetição, os limitadores das instruções repetidas torna-se simples e de uso natural.

5.1. Repita-Até

A estrutura Repita-Até é caracterizada pela execução das instruções pelo menos uma vez antes da verificação da necessidade de executar o laço. Desta forma, escrito com a simbologia de decisão, o caminho Falso indica que as instruções serão executadas novamente, enquanto que o caminho Verdadeiro leva ao fim da estrutura. Note que não existe instruções no caminho Falso.

Figura 2.30: Estrutura Repita-Até com símbolo de decisão. Assim como na estrutura condicional, devem ser utilizados um símbolo de decisão, um conector

e duas caixas de texto com as identificações do resultado da condição, além do fluxo de dados. A figura 2.31 mostra a forma equivalente da estrutura utilizando os elementos de limite de laço

de repetição. O símbolo inicial deve conter a palavra Repita e o símbolo final deve conter a palavra Até seguida por uma expressão lógica.

Figura 2.31: Estrutura Repita-Até com elementos limitadores. 5.2. Enquanto-Faça

Ao contrário da estrutura Repita-Até, a estrutura repetitiva Enquanto-Faça faz a verificação da condição antes de executar as instruções no interior do laço. Desta maneira, existe a possibilidade de que as instruções não sejam executadas nenhuma vez.

Ao utilizar a simbologia de decisão, as instruções que serão repetidas devem ser posicionas no caminho Verdadeiro, sendo caminho Falso a saída do fluxo de dados da estrutura. Note que não devem existir instruções entre o ponto de retorno (representado por um conector) e a condição.

Assim como na estrutura Repita-Até, devem ser utilizados um símbolo de decisão, um conector e duas caixas de texto com as identificações do resultado da condição.


Figura 2.32: Estrutura Enquanto-Faça com símbolo de decisão. Quando a simbologia de limite de laço for utilizada, o texto do primeiro símbolo começa com a

palavra Enquanto. Depois uma condição lógica deve ser indicada, antecedendo a palavra Faça. O símbolo final deve conter o texto Fim Enquanto.

Figura 2.33: Estrutura Enquanto-Faça com elementos limitadores. 5.3. Para-Até-Faça

A estrutura repetitiva Para-Até-Faça é um caso particular da estrutura Enquanto-Faça. Ou seja, a simbologia utilizada em ambos os casos é a mesma.

A principal diferença entre a estrutura Para-Até-Faça e as demais estruturas de repetição consiste no fato de que existe, obrigatoriamente, um contador ordinal (inteiro o caractere) que define o número de vezes que o laço será executado. Ou seja, não é possível fazer repetições que executem o laço um número indeterminado, embora finito, de vezes como nas outras estruturas repetitivas.

O primeiro elemento da estrutura Para-Até-Faça é um processo que indica a situação inicial do contador, ou seja, o contador deve receber um valor inicial. Este processo deve ser representado antes do elemento de decisão.

O contador deve ser acrescido em uma unidade após a execução das instruções pertencentes ao algoritmo, ou seja, a última instrução do caminho de retorno deve ser o incremento do contador.

Outra particularidade da estrutura consiste no conteúdo da decisão. A repetição da estrutura Para-Até-Faça ocorre quando a condição garante que o valor da variável de controle (contador) seja menor ou igual ao valor final estipulado. Caso contrário, o laço é encerrado. Deve-se notar que ao término da execução da estrutura, o valor do contador é uma unidade maior do que o valor final estipulado.

Figura 2.34: Estrutura Para-Até-Faça com símbolo de decisão.


Quando a simbologia de limite de laço é utilizada, os processos de preparo e incremento não devem ser adicionados como na simbologia de decisão. Estão previstos no interior do primeiro símbolo de limite de laço e devem conter os seguintes termos:

• o texto é iniciado com a palavra Para; • o valor inicial deve ser atribuído à variável de controle; • escrever a palavra Até; • indicar o valor final desejado para o contador; • terminar o primeiro símbolo com a palavra Faça. O símbolo final deve conter apenas o texto Fim Para.

Figura 2.35: Estrutura Para-Até-Faça com elementos limitadores. Deve-se notar que o incremento do contador não é representado graficamente, embora a

estrutura, implicitamente, acrescenta uma unidade na variável de controle. Ao término da execução da estrutura, o valor do contador é numericamente igual ao valor final

mais uma unidade. Isto ocorre em função das características da estrutura Para-Até-Faça sendo independente da simbologia utilizada.

6. Sub-rotinas

A técnica top-down é utilizada para a resolução de problemas, dividindo um problema em problemas menores. A divisão continua até que todos os problemas sejam de solução conhecida e, se possível, simples. A partir do teorema da superposição, após a resolução de todos os problemas menores, a solução do problema principal também é obtida.

As ferramentas utilizadas para a implementação da técnica top-down para resolver problemas em algoritmos são as sub-rotinas. Os problemas menores são representados por pequenos algoritmos isolados dos demais, mas que podem ser executados a qualquer momento, quantas vezes forem necessárias.

O símbolo da sub-rotina é derivado do símbolo de processo, entretanto, existem duas barras laterais que os diferenciam. Embora seja tratado como um processo possui a diferença no símbolo para indicar que não se trata de um processamento realizado por uma instrução conhecida pela Unidade Central de Processamento (C.P.U.) do computador, mas que foi criada por algum programador e utiliza um conjunto das instruções da C.P.U. para resolver um problema.

Figura 2.36: Símbolo da sub-rotina. O símbolo tem duas aplicações: servir como cabeçalho para a criação da sub-rotina e permitir a

sua chamada, ou seja, a sua execução.


A estrutura de uma sub-rotina é definida pelo símbolo do processo predefinido, seguido de um algoritmo completo, desde o início até o fim.

Figura 2.37: Estrutura de uma sub-rotina. Uma vez definida, a sub-rotina pode ser chamada pelo programa principal ou por uma sub-

rotina. O número de vezes que a sub-rotina é executada não interfere com os valores calculados, pois suas variáveis são locais, ou seja, somente existem durante a sua execução. Uma sub-rotina também pode utilizar variáveis globais, se necessário.

Figura 2.38: Chamada de uma sub-rotina. Embora existam dois tipos de sub-rotinas, detalhados mais adiante, o conteúdo do símbolo de

processamento predefinido possui a mesma característica para ambos os casos. Deve-se identificar a sub-rotina pelo seu nome seguido, se necessário, de uma lista de parâmetros, delimitadas por parênteses.

Figura 2.39: Cabeçalho de uma sub-rotina. O nome da sub-rotina deve seguir algumas regras, normalmente associadas à linguagem de

programação utilizada. Além disso, não pode ter o mesmo nome de nenhuma instrução ou palavra reservada da linguagem.

Os parâmetros da sub-rotina, se houverem, devem ser expressos dentro dos parênteses que sucedem o nome da sub-rotina. Representam o canal de comunicação entre a sub-rotina e o trecho do algoritmo que a chamou. Os parâmetros podem ser classificados de duas maneiras: passados por valor ou por referência.

• Passagem de parâmetros por valor: estes parâmetros atuam como entrada de informações para a sub-rotina. É apenas uma cópia do conteúdo da variável original. Se o parâmetro for modificado no interior da sub-rotina, a variável original não é alterada;

• Passagem de parâmetros por referência: estes parâmetros atuam com um canal bidirecional para a troca de informações entre uma sub-rotina e o trecho de um algoritmo que a chamou. Se o parâmetro for alterado no interior da sub-rotina, a variável original também será. A palavra var deve anteceder os parâmetros passados por referência.

Além disso, a lista de parâmetros deve respeitar as regras: • os elementos da lista de parâmetros são separados por vírgula; • caso haja uma mudança entre os tipos de parâmetro (valor ou referência) o elemento

separador deve ser um ponto-e-vírgula; • o parâmetro após um ponto-e-vírgula é passado por valor, a menos que a palavra var seja

utilizada; • se não existirem parâmetros, os parênteses não devem ser representados.


Embora o conteúdo do símbolo da sub-rotina possua as mesmas características para os dois tipos de sub-rotinas, a chamada de um procedimento é diferente de uma função, como apresentado a seguir junto com a descrição de cada um dos tipos.

6.1. Procedimentos

Os procedimentos são sub-rotinas que podem realizar executar qualquer conjunto de instruções em seu interior, desde entrada de dados, até cálculos que utilizam repetições.

O procedimento não retorna nenhum valor. Entretanto, os parâmetros passados por referência podem trazer informações obtidas pelo algoritmo executado no interior do procedimento.

Figura 2.40: Estrutura de um procedimento. Para executar um procedimento, o símbolo de processo predefinido deve ser utilizado. Em seu

interior deve-se escrever o nome do procedimento e, entre parênteses, a lista de parâmetros, se houverem. Na chamada do procedimento, apenas a vírgula deve ser utilizada para separar os elementos da lista de parâmetros, não importando se o parâmetro é passado por valor ou referência. Além disso, a palavra var não deve ser informada.

Figura 2.41: Chamada de um procedimento. 6.2. Funções

As funções são sub-rotinas que podem realizar executar qualquer conjunto de instruções em seu interior. Entretanto, a sua principal aplicação é a realização de cálculos.

A função retorna um único valor, em seu próprio nome. Este valor pode representar um dado de qualquer tipo, como números, caracteres, lógicos ou estruturas de dados homogêneas (variáveis indexadas) e heterogêneas (registros).

No fluxograma em que o algoritmo da função é descrito, deve haver, obrigatoriamente, uma instrução que armazena o resultado no nome da função. Normalmente, esta é a última instrução de uma função. Caso a função retorne uma estrutura de dados homogênea ou heterogênea, todos os elementos devem ser preenchidos.

Início

Fim

Instruções

NomeF(Lista de Parâmetros)

NomeF ← Resultado

Figura 2.42: Estrutura de uma função.


Além do retorno natural no nome da função, é possível utilizar parâmetros passados por referência para trazer mais informações obtidas pelo algoritmo executado pela função.

A chamada da função pode ocorre em duas situações. O resultado da função pode ser armazenado em uma variável ou comparado com outro valor em uma estrutura condicional ou repetitiva. Ou seja, a chamada da função é realizada em expressões.

A figura 2.43 mostra a chamada de uma função utilizando a simbologia de processo predefinido. Nesta situação, o valor retornado deve ser atribuído a uma variável.

Figura 2.43: Chamada de uma função em um processo. Caso o valor retornado deva ser comparado com outro, os símbolos de decisão ou limite de laço

de repetição são utilizados normalmente, sem a adição das barras laterais, como mostram os exemplos das funções NomeCliente e OrdemMatriz da figura 2.44:

Figura 2.44: Chamada de uma função em uma comparação. Ao chamar uma função, uma lista de parâmetros, se houverem, deve ser informada entre

parênteses após o nome da função. Apenas a vírgula deve ser utilizada para separar os elementos da lista de parâmetros, não importando se o parâmetro é passado por valor ou referência. A palavra var não deve utilizada para diferencias os tipos de parâmetros.

7. Arquivos de acesso aleatório 7.1. Introdução

As instruções apresentadas até este ponto estão associadas a um programa cujos dados podem ser acessados apenas durante a sua execução. Ao encerrar o programa e executá-lo novamente, os dados anteriores não mais estarão acessíveis.

Quando há necessidade de armazenar as informações colhidas ou processadas por um programa, torna-se necessário utilizar arquivos de dados. Estes arquivos possuem características próprias definidas a partir de cada problema.

A leitura dos dados do arquivo não precisa ser necessariamente seqüencial. Ou seja, é possível acessar o quinto registro diretamente, sem passar pelos quatro primeiros. Isto é possível graças a um elemento denominado ponteiro, que aponta para um único registro do arquivo por vez e sua posição pode ser manipulada livremente.

Para permitir a manipulação dos dados, é necessário definir algumas instruções comuns às linguagens de programação. Estas instruções podem ser divididas em dois grupos: o acesso direto aos dados e outras instruções gerais, descritas a seguir.


7.2. Acesso aos dados

Nesta seção será apresentado um conjunto de instruções relacionadas diretamente ao acesso dos dados de um arquivo. Para identificar o acesso aos dados, tais instruções devem ser escritas em um símbolo específico.

Figura 2.45: Símbolo de acesso direto aos dados de um arquivo. No interior do símbolo, deve ser especificada a ação por meio de algumas instruções. Sob o

ponto de vista de algoritmo, tais instruções não são classificadas como sub-rotinas e seus parâmetros não são limitados por parênteses.

• Crie: esta instrução é responsável pela criação de um arquivo sem nenhum dado gravado. Deve

ser especificado o nome do arquivo que se deseja criar, informando a variável do arquivo lógico. O ponteiro indicará a primeira posição válida do arquivo, normalmente representada por zero.

Figura 2.46: Criação de um arquivo. • Abra: permite abrir um arquivo criado previamente sem que haja perda de dados. Considere que

ao abrir o arquivo, o ponteiro é direcionado para a primeira posição válida. Esta instrução requer a identificação do arquivo lógico que será aberto.

Figura 2.47: Abertura de um arquivo. • Feche: ao executar esta instrução, garante-se que os dados gravados não serão perdidos. Uma

vez que o arquivo esteja fechado, as demais instruções não poderão ser utilizadas.

Figura 2.48: Fechar um arquivo. • Escreva: utilizada para gravar informações em um arquivo. Os dados serão gravados na posição

indicada pelo ponteiro que pode ser no final do arquivo, criando um novo registro, o em outro local, substituindo das informações existentes.


A instrução Escreva necessita de duas informações: o nome do arquivo lógico em que as informações serão armazenadas e os dados que serão gravados. Estes dois elementos são separados por vírgula.

Figura 2.49: Gravar um registro em um arquivo.

Os dados que serão gravados, normalmente em uma variável definida por uma estrutura de dados heterogênea, ou seja, representam um conjunto de informações. Caso apenas o nome da variável seja expressa no símbolo, todos os campos serão gravados. É possível gravar apenas um campo específico, sem alterar os demais. Para tal, deve-se especificar o nome do campo escrevendo o nome da variável, seguida por um ponto e pelo nome do campo.

Figura 2.50: Gravar um campo de um registro em um arquivo. • Leia: utilizada para ler informações em um arquivo. Os dados serão lidos da posição indicada

pelo ponteiro. Deve-se observar com atenção a posição do ponteiro para não tentar ler uma posição que não existe. A instrução Leia necessita de duas informações: o nome do arquivo lógico e nome da variável que receberá os dados lidos. Estes dois elementos são separados por vírgula.

Figura 2.51: Ler um registro de um arquivo. Ao identificar um campo durante a leitura dos dados, somente as informações referentes ao campo serão lidas. Os demais campos da variável permanecerão inalterados.

Figura 2.52: Ler um campo de um registro de um arquivo.


7.3. Demais instruções

Existem outras instruções que são necessárias para a manipulação de arquivos, mas não acessam os dados armazenados diretamente. Estas instruções serão expressas, normalmente, no interior do símbolo de processo.

• Associe: estabelece uma relação entre o arquivo lógico e o arquivo físico. Uma vez definida a

relação, as demais instruções devem atuar sobre a variável que representa o arquivo lógico. O arquivo físico deve ser um texto contendo o caminho, o nome e a extensão do arquivo, por exemplo, ‘c:\temp\cliente.dat’. Estas duas informações devem ser separadas por uma vírgula.

Figura 2.53: Associar os arquivos lógico e físico. • Posicione: permite definir a posição do ponteiro em um arquivo. O uso correto desta instrução

é fundamental para a manipulação dos dados, uma vez que o ponteiro aponta para um único registro por vez. Antes de utilizar as instruções Escreva ou Leia é conveniente posicionar o ponteiro no registro correto.

Figura 2.54: Definir a posição do ponteiro em um arquivo. • Posição: esta função retorna um número inteiro que representa a posição atual do ponteiro. Seu

parâmetro deve ser o nome da variável do arquivo lógico. Por se tratar de uma função, deve ser chamada em uma expressão, ou seja, pode ser escrita em um processo, decisão ou limite de laço de repetição, como mostrado nos exemplos.

Figura 2.55: Obter a posição atual do ponteiro em um arquivo. • Tamanho: esta função retorna um número inteiro que representa a quantidade de registros do

arquivo. Possui um parâmetro que deve ser o nome da variável do arquivo lógico. Assim como as demais funções, pode ser utilizado em um processo, decisão ou repetição, como mostrado no exemplo a seguir.

Figura 2.56: Obter a quantidade de registros de um arquivo.


Capítulo 3 – Exemplos em Pascal e Delphi

1. Pascal

1.1. Exemplo 1 – Conversão de temperatura

O primeiro exemplo consiste no cálculo de uma temperatura, expressa em F° , a partir de uma temperatura expressa em C° . Sabe-se que a relação entre as temperaturas pode ser descrito pela seguinte equação:

( )329

5−⋅=

FCTT

Entretanto, para calcular o valor da temperatura em F° , é necessário reescrever a equação,

isolando a variável F

T :

CFTT ⋅+=

5

932

Desta maneira, o algoritmo que permite resolver o problema pode ser dividido em três pontos

fundamentais: • leitura do valor da temperatura em C° ; • cálculo da temperatura correspondente em F° ; • um exibição do resultado obtido.

O fluxograma a seguir representa a solução gráfica do algoritmo apresentado. Note que, embora

cada símbolo gráfico possua um significado (entrada manual, exibição, etc.), é conveniente fazer comentários sobre um determinado elemento do fluxograma ou de um bloco, facilitando uma futura leitura do mesmo.

Início

'Digite a temperatura em °C: '

TC

TF ← 32 + 9/5*TC

'A temperatura em °F é: ', TF

Fim

Entrada da temperatura em °C

Conversão de temperatura

Exibição da temperatura em °F

Figura 3.1: Conversão de temperatura. Na transcrição do fluxograma para uma linguagem de programação, o usuário deve ficar atento

para as peculiaridades existentes em cada linguagem. No exemplo da linguagem Pascal, devemos


declarar as variáveis que serão utilizadas no programa, definindo o seu tipo. Além disso, outras palavras reservadas devem constar, formando o cabeçalho do programa.

Deve-se notar uma semelhança entre o conteúdo dos símbolos e cada estrutura correspondente da linguagem Pascal.

program Temperatura;

// varáveis do programa

var

TF, TC: real;

begin

// entrada de dados

Writeln('Digite a temperatura em °C: ');

Readln(TC);

// cálculo da temperatura

TF := 32 + 9/5*TC;

// exibição da resposta

Writeln('A temperatura em °F é: ', TF);

end. 1.2. Exemplo 2 – Raízes de uma equação do segundo grau

Para exemplificar o uso de uma estrutura condicional composta, será realizado o cálculo das raízes de uma equação do segundo grau cxbxay +⋅+⋅= 2 , sendo os coeficientes a, b e c informados pelo usuário.

Figura 3.2: Cálculo das raízes da equação do segundo grau. Alguns cuidados devem ser tomados nos cálculos das variáveis. Deve-se notar a presença das

funções matemáticas sqr(x) e sqrt(x), que representam, respectivamente 2x e x . Além disso,


uma especial atenção deve ser direcionada para os parênteses existentes nos numeradores e denominadores dos cálculos das variáveis x1 e x2.

O código-fonte apresentado a seguir é muito parecido com o fluxograma apresentado, sendo a declaração de variáveis a principal diferença conceitual.

program Baskara;

// variáveis do programa

var

a, b, c, delta, x1, x2: real;

begin

// entrada de dados

Writeln('Digite os valores de a, b e c: ');

Readln(a, b, c);

// cálculo e verificação do delta

delta := sqr(b)-4*a*c;

if delta >= 0 then

begin // caso existam raízes reais

// cálculo das raízes

x1 := (-b+sqrt(delta))/(2*a);

x2 := (-b-sqrt(delta))/(2*a);

Writeln('As raízes são: ', x1, ' e ', x2);

end

else // caso existam raízes reais

Writeln('Não existem raízes reais.');

end. 1.3. Exemplo 3 – Calculadora com quatro operações

Neste exemplo veremos como criar uma calculadora com as operações básicas da aritmética (sem a preocupação com eventuais problemas que possam ocorrer com a divisão). Além disso, a calculadora é executada continuamente, sendo encerrada apenas quando o usuário responder negativamente à pergunta: “Deseja informar novos valores?”.

Verifica-se que o fluxograma da figura 3.3 utiliza uma estrutura condicional caso para verificar qual é a operação que deve ser realizada. Deve-se lembrar que a estrutura caso aceita apenas variáveis ordinais em sua pergunta (inteiros ou caracteres). No exemplo, pode-se notar que os caracteres foram utilizados, não somente pelo seu conteúdo não numérico, mas também pela presença das aspas.

Outro ponto de destaque consiste no laço de repetição que envolve todas as instruções referentes à calculadora. Desta maneira, o algoritmo principal é executado indefinidamente, até que o usuário não mais deseje executá-lo, digitando o caractere ‘N’, sob a forma maiúscula ou minúscula. Pode-se notar o uso do operador lógico OR na condição da estrutura Repita-Até.


Figura 3.3: Calculadora com quatro operações. Com o código-fonte aprestado a seguir, pode-se comparar com o fluxograma:

program Calculadora;

// variáveis do programa

var

op: char;

a, b, r: real;

begin

repeat // laço para gerenciamento do programa

// entrada de dados

Writeln('Digite dois valores: ');

Readln(a, b);

Write('Escolha o operador (+), (-), (*) ou (/): ');

Readln(op);


// cálculos

case op of

'+': R := a + b;

'-': R := a - b;

'*': R := a * b;

'/': R := a / b;

end; // fim da estrutura caso

// exibição do resultado

Writeln('O resultado é = ', R);

// para verificar se o laço será executado novamente

Write('Deseja informar novos valores? (S/N): ');

Readln(op);

until (op = 'n') or (op = 'N');

end. 1.4. Exemplo 4 – Cálculos com vetores

O uso de variáveis indexadas é muito semelhante na linguagem gráfica e na linguagem Pascal. Entretanto, a criação de um tipo de dado para comportar as componentes de um vetor não é explicitada no fluxograma. Além disso, a variável indexada de um fluxograma não possui um limite físico de tamanho.

O exemplo mostra a elaboração de um programa para a realização de cálculos com vetores pertencentes ao 3ℜ . Para realizar a soma vetorial, o produto escalar e o produto vetorial, são necessários dois vetores digitados em um procedimento. Além disso, também será necessário exibir os resultados, sendo que alguns destes também são vetores.

O problema pode ser dividido em seis fluxogramas, sendo:

• um procedimento para a entrada das coordenadas de um vetor; • um procedimento para a exibição das coordenadas de um vetor; • uma função que soma dois vetores e retorna um terceiro vetor; • uma função para calcular o produto escalar; • uma função que calcula e retorna o vetor que representa o produto vetorial de dois vetores; • um programa principal para gerenciar os dados e as chamadas das sub-rotinas de cálculo.


Produto_Escalar (A, B)

Início

Para i ← 1 até 3 faça

Fim Para

Fim

S ← S + A[i]*B[i]

S ← 0

Produto_Escalar ← S

Figura 3.4: Cálculos vetoriais. Como pode ser observado, as instruções no final das funções armazenam os valores calculados

no nome da função, não importando se a função retorna um ou vários valores. No caso do procedimento para a entrada dos dados, fez-se necessário o uso da passagem de um parâmetro por referência, garantindo que o programa principal recebesse os valores digitados no interior do procedimento.

A seguir, temos o código-fonte. Deve-se notar com atenção as declarações do tipo TVetor, além dos cabeçalhos das funções e procedimentos que embora sejam semelhantes aos do fluxograma, devem conter informações importantes para o compilador.

program Vetores;

// definição de um tipo de variável

type

TVetor = array[1..3] of real;

// procedimento para digitar a as coordenadas de UM vetor

procedure Digita_Vetor(var a: TVetor);

var i: integer;

begin

Writeln('Digite as componentes de um vetor: ');

for i := 1 to 3 do

Readln(a[i]);

end;


// retorna a soma vetorial

function Soma(a, b: TVetor): TVetor;

var i: integer;

begin

for i := 1 to 3 do

Soma[i] := a[i] + b[i];

end;

// retorna o produto escalar

function Produto_Escalar(a, b: TVetor): Real;

var i: integer;

s: real;

begin

s := 0;

for i := 1 to 3 do

s := s + a[i]*b[i];

Produto_Escalar := s;

end;

// retorna o produto vetorial

function Produto_Vetorial(a, b: TVetor): TVetor;

begin

Produto_Vetorial[1] := a[2]*b[3] - a[3]*b[2];



end;

// procedimento para exibir a as coordenadas de UM vetor

procedure Exibe_Vetor(a: TVetor);

var i: integer;

begin

Writeln('As componentes do vetor são: ');

for i := 1 to 3 do

Writeln(a[i]);

end;

// variáveis do programa principal

var

u, v: TVetor;

i: integer;

resp: real;

begin

// entrada de dados

Digita_Vetor(u);

Digita_Vetor(v);

// chamada para sub-rotinas e exibição

Exibe_Vetor(Soma(u,v));

Writeln('Produto Escalar = ', produto_escalar(u,v));

Exibe_Vetor(Produto_Vetorial(u,v));

end.


1.5. Exemplo 5 – Cálculo do determinante de uma matriz de ordem N

O exemplo a seguir mostra a elaboração de um algoritmo para o cálculo do determinante de uma matriz de ordem N. Para tal, serão criados dois fluxogramas: o programa principal para o gerenciamento do algoritmo e uma função para o cálculo do determinante.

Figura 3.5: Cálculo do determinante. Como pode ser observado, existe uma chamada recursiva na função, ou seja, a sub-rotina

Determinante fez uma chamada para a sub-rotina Determinante. Para calcular o determinante, o método utilizado foi a expansão de Laplace, subdividindo uma matriz de ordem k em k matrizes de ordem k-1.


A subdivisão se encerra quando a matriz que é recebida possui ordem 2, uma vez que o cálculo do determinante de uma matriz 2x2 é simples.

Figura 3.6: Programa principal. O código-fonte apresenta a implementação na linguagem Pascal. Note com atento a declaração

do tipo para armazenar a matriz, dos dados acrescidos ao cabeçalho que não são exibidos no fluxograma.

program Matriz;

// definição de um tipo de variável

// neste exemplo a ordem da matriz pode ser uma valor entre 1 e 100

type

TMatriz = array[1..100, 1..100] of real;

function Determinante(M: TMatriz; N: integer): real;

// variáveis locais da função

var i, j, k, sinal, L, C: integer;

s: real;

M1: TMatriz;

Begin

// valores iniciais

s:= 0;

sinal := 1;


// verifica se já pode calcular

if N > 2 then

begin

for k := 1 to n do // k-> entrada da matriz

begin

// Cria uma matriz (N-1)x(N-1)

L := 1;

for i := 2 to n do

// para eliminar a primeira linha, i começa em 2

begin

C := 1;

for j := 1 to n do

// elimina a coluna da entrada da matriz

if j <> k then

begin

M1[L,C] := M[i,j];

C := C + 1;

end;

L := L + 1;

end;

// soma o valor acumulado com a multiplicação da entrada da

// matriz pelo co-fator

s := s + sinal*M[1,k]*Determinante(M1,n-1);

sinal := -sinal

end;

Determinante := s;

end

else Determinante := M[1,1]*M[2,2]-M[1,2]*M[2,1]; // 2x2

end;

// variáveis para o programa principal

var

L, C, N: integer;

M: TMatriz;

begin

// entrada de dados

Write('Digite a ordem da matriz: ');

Readln(N);

Writeln('Digite os elementos da matriz: ');

for L := 1 to N do

for C := 1 to N do

Readln(M[L,C]);

// cálculo e exibição do determinante

Writeln('O valor do determinante é: ', Determinante(M, N));

end.


2. Delphi 2.1. Peculiaridades

Algumas dúvidas podem surgir quando um programador for elaborar um algoritmo sob a forma gráfica, para o Delphi. Na verdade, um algoritmo não é elaborado para uma linguagem especifica, ou seja, é um instrumento de comunicação entre profissionais da área da Computação e é independente da linguagem utilizada para a sua implantação.

O ambiente Delphi permite ao programador criar aplicativos utilizando a linguagem Object Pascal, ou seja, é um paradigma diferente do existente quando um programa procedural é criado. Desta forma, existem algumas diferenças ligadas à linguagem e não devem ser consideradas na elaboração de um algoritmo.

Além disso, mesmo estando ligado à filosofia RAD (Rapid Application Development), o Delphi utiliza o paradigma da programação orientada ao objeto, sendo a UML (Unified Modeling Language) a linguagem mais adequada à modelagem de tais aplicativos.

A utilização de objetos pode gerar discussão quanto ao uso de alguns símbolos do fluxograma. Por exemplo, para ler um valor deve-se utilizar o símbolo de entrada manual ou um processo para armazenar o conteúdo da propriedade Text de um objeto do tipo TEdit em uma variável?

Discussões como estas serão deixadas em um segundo plano neste trabalho. O enfoque é a criação de algoritmos sob a forma gráfica, ou seja, o modelo simples de leitura, processamento e exibição será utilizado, independente da linguagem ou objetos utilizados.

Os tópicos a seguir mostram algumas simplificações que podem ser utilizadas, uma vez que uma parte do aplicativo não é gerado pelo programador. Serão considerados apenas os métodos que devem ser preenchidos pelo programador.

O programa principal

Ao salvar um projeto no Delphi, é solicitado ao programador que indique o nome de cada unidade e o do projeto. O nome do projeto está associado diretamente ao programa principal do aplicativo. Na maioria das vezes, este arquivo permanece inalterado pelo programador. Desta forma, a menos que haja interferência humana direta no arquivo, o programa principal não será representado no fluxograma.

Desta maneira, apenas serão criados os algoritmos das sub-rotinas que o programador criar, seja pela digitação do código-fonte ou pelo preenchimento de uma sub-rotina associada a um objeto criada pelo ambiente Delphi.

O cabeçalho das sub-rotinas

As sub-rotinas criadas pelo Delphi para que o programador possa preencher são, na verdade, métodos de objetos que são executados quando um determinado evento ocorre. O nome do procedimento que representa o método possui as seguintes componentes:

• o nome da classe criada pelo ambiente Delphi; • o nome do objeto utilizado; • o tipo de evento sentido pelo objeto; • eventuais parâmetros de entrada ou saída. A simplificação que pode ser utilizada para a criação do nome do procedimento no fluxograma

consiste em utilizar apenas os dois itens intermediários, ou seja, o nome do objeto seguido do tipo de evento.

Quando o usuário der um clique sobre o objeto Button1, temos Button1Click. Ao criar o Formulário, executa-se o procedimento FormCreate. A regra é aplicada mesmo para os objetos que


não possuem o nome original. Por exemplo, BtnSomaClick representa o clique sobre o botão BtnSoma.

Leitura e exibição de dados

Ao comparar programas simples feitos com a linguagem Pascal e Object Pascal pode-se notar que a principal diferença está na entrada e saída de dados. Em Pascal, utilizam-se as instruções Readln e Writeln, respectivamente, para ler e exibir valores. Ao utilizar os objetos do Delphi, a entrada de dados pode ser realizada por componentes do tipo TEdit, TCheckBox, TRadioGroup, TStringGrid, entre outros. Os objetos do tipo TLabel, TMemo, TStringGrid e diversos outros podem ser utilizados para exibir os resultados.

O símbolo de entrada de dados manual é utilizado para informações obtidas pelo teclado ou pelo mouse, independente do componente utilizado. No interior do símbolo, devem ser escritas as variáveis que serão preenchidas com o conteúdo das propriedades que contém os valores informados pelo usuário.

Outra particularidade do Delphi que não será considerada é o fato de que tudo o que está escrito no formulário e em seus objetos é um texto. Embora seja necessário converter o texto de um objeto TEdit para número ao armazená-lo em uma variável real quando o código-fonte é escrito, no fluxograma basta escrever o nome da variável no símbolo de entrada de dados manual. Veja o exemplo a seguir comparando o código-fonte com a figura 3.7:

VarInteira := StrToInt(Edit1.Text);

VarReal := StrToFloat(Edit2.Text);

VarTexto := Edit3.Text;

Figura 3.7: Leitura de valores. De maneira semelhante, as variáveis que contém os valores que serão exibidos devem ser escritas

no símbolo de exibição, não importando qual é o componente utilizado, como mostra o exemplo: For i := 1 to 3 do

StringGrid1.Cells[1,i] := FloatToStr(Vetor[i]);

Memo1.Lines.Add(‘Resultado: ’ + IntToStr(x));

Para i ← 1 Até 3 Faça

Vetor[i]

Fim Para

‘Resultado’, x

Figura 3.8: Exibição de valores.


2.2. Exemplo 1 – Manipulação de propriedades dos objetos O problema apresentado neste exemplo consiste na exibição dos valores que seguem a regra 2xy = . Os valores de y devem ser calculados a partir de um intervalo fechado discreto [ ]finalvalorinicialvalor ; . Os elementos do intervalo devem ser separados por um valor denominado passo . O usuário deve digitar os valores limitantes do intervalo, bem como o passo , em componentes

do tipo TEdit. Ao clicar sobre o botão Montar Tabela os valores de x e y devem ser exibidos em um componente do tipo TMemo. O formulário é apresentado na figura 3.9.

Figura 3.9: Interface do aplicativo. O fluxograma a seguir mostra as instruções executadas quando o usuário der um clique sobre o

botão Montar Tabela. Deve-se notar que embora o aplicativo possua objetos, as operações básicas são as mesmas, ou seja, leitura de valores, processamento e exibição.

Início

Fim

x, y

x, xf, dx

Enquanto x <= xf Faça

Fim Enquanto

y ← sqr(x)

x ← x + dx

BtnTabelaClick

Figura 3.10: Fluxograma do botão Montar Tabela. O código-fonte a seguir mostra a unidade relacionada ao formulário apresentado. Deve-se notar

que o fluxograma criado representa o procedimento BtnTabelaClick.


unit UTabela;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics,

Controls, Forms, Dialogs, StdCtrls;

type

TForm1 = class(TForm)

Memo1: TMemo;

GroupBox1: TGroupBox;

Label1: TLabel;

Label2: TLabel;

Label3: TLabel;

Edit1: TEdit;

Edit2: TEdit;

Edit3: TEdit;

BtnTabela: TButton;

procedure BtnTabelaClick(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

// Botão Monta Tabela

procedure TForm1.BtnTabelaClick(Sender: TObject);

var x, xf, y, dx: real;

begin

// entrada de dados

x := StrToFloat(Edit1.Text);

xf := StrToFloat(Edit2.Text);

dx := StrToFloat(Edit3.Text);

// limpa o conteúdo do memo

Memo1.Clear;

// laço para preencher a tabela

while x < xf do

begin

y := sqr(x); // calcula x²

// exibe no memo

Memo1.Lines.Add('x = '+ FloatToStr(x) +' e y = '+ FloatToStr(y));

x := x + dx; // incremento do x

end;

end;

end.


O código-fonte possui a instrução Memo1.Clear que não está representada no fluxograma. Isto ocorre por se tratar de uma instrução específica e não relevante à resolução do problema.

2.3. Exemplo 2 – Manipulação básica de arquivos

Este exemplo a seguir mostra como elaborar um algoritmo para manipular os dados em um arquivo referente a um Pet Shop. O aplicativo deve permitir ao usuário:

• adicionar novos registros no final do arquivo; • exibir todas as informações do arquivo em um objeto do tipo TStringGrid; • alterar os dados de um registro informado em um objeto do tipo TEdit.

Sabe-se que o arquivo deve armazenar • o nome do proprietário; • o endereço; • o nome do animal; • o ano de nascimento do animal e • a classificação do animal. Deve-se lembrar que apenas um arquivo aberto pode ser manipulado. Além disso, para garantir

que os dados não serão perdidos, o arquivo deve ser fechado no final.

Figura 3.11: Interface do aplicativo.

A seguir são apresentados os fluxogramas necessários para a resolução do problema.


Figura 3.12: Fluxogramas do aplicativo. Deve-se notar que além dos métodos dos três botões, são necessários os métodos FormCreate

e FormClose para executar ações de preparo e encerramento do arquivo. unit UPetShop;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics,

Controls, Forms,Dialogs, StdCtrls, ExtCtrls, Grids;

type

TForm1 = class(TForm)

BtnGravar: TButton;

BtnLeitura: TButton;

BtnAlterar: TButton;

Label1: TLabel;

Label2: TLabel;

Label3: TLabel;

Label4: TLabel;

Label5: TLabel;

Edit1: TEdit;

Edit2: TEdit;

Edit3: TEdit;

Edit4: TEdit;

Edit5: TEdit;

RadioGroup1: TRadioGroup;

Bevel1: TBevel;

StringGrid1: TStringGrid;

procedure BtnGravarClick(Sender: TObject);

procedure BtnLeituraClick(Sender: TObject);

procedure BtnAlterarClick(Sender: TObject);

procedure FormCreate(Sender: TObject);

procedure FormClose(Sender: TObject; var Action: TCloseAction);


private

{ Private declarations }

public

{ Public declarations }

end;

// Definição dos campos do registro

type

TPetShop = record

Proprietario: string[50];

Endereco: string[50];

NomeAnimal: string[20];

Nascimento: integer;

Classificacao: integer;

end;

// variáveis globias

var

Form1: TForm1;

Ficha: TPetShop; // dados de uma ficha

arq: file of TPetShop; // arquivo lógico

implementation

{$R *.dfm}

// Botão Gravar

procedure TForm1.BtnGravarClick(Sender: TObject);

begin

// preenche dos campos de uma ficha

Ficha.Proprietario:= Edit1.Text;

Ficha.Endereco:= Edit2.Text;

Ficha.NomeAnimal:= Edit3.Text;

Ficha.Nascimento:= StrToInt(Edit4.Text);

Ficha.Classificacao:= RadioGroup1.ItemIndex;

// posiciona o ponteiro no final do arquivo

Seek(arq, FileSize(arq));

// grava a ficha no arquivo

Write(arq, Ficha);

end;

// botão Leitura

procedure TForm1.BtnLeituraClick(Sender: TObject);

var i: integer;

begin

// verifica todos os registros

for i := 0 to FileSize(arq)-1 do

begin

// aponta para um registro

Seek(arq,i);

// lê o conteúdo do registro

Read(arq, Ficha);

// exibe o conteúdo da ficha

StringGrid1.Cells[0,i+1] := IntToStr(i);

StringGrid1.Cells[1,i+1] := Ficha.Proprietario;

StringGrid1.Cells[2,i+1] := Ficha.Endereco;


StringGrid1.Cells[3,i+1] := Ficha.NomeAnimal;

StringGrid1.Cells[4,i+1] := IntToStr(Ficha.Nascimento);

StringGrid1.Cells[5,i+1] := RadioGroup1.Items

[Ficha.Classificacao];

end;

end;

// quando o formulário for criado, aplica as configurações iniciais

procedure TForm1.FormCreate(Sender: TObject);

begin

// associa o arquivo lógico com o arquivo físico

AssignFile(arq,'petshop.dat');

// cria o arquivo

Rewrite(arq);

// formata a tabela do StringGrid

StringGrid1.Cells[1,0] := 'Proprietário';

StringGrid1.Cells[2,0] := 'Endereço';

StringGrid1.Cells[3,0] := 'Nome do Animal';

StringGrid1.Cells[4,0] := 'Ano';

StringGrid1.Cells[5,0] := 'Tipo do Animal';

StringGrid1.RowCount := 52;

StringGrid1.ColWidths[0] := 25;






end;

// quando o formulário for criado, fecha o arquivo

procedure TForm1.FormClose(Sender: TObject; var

Action: TCloseAction);

begin

CloseFile(arq);

end;

// Botão Alterar

procedure TForm1.BtnAlterarClick(Sender: TObject);

var reg: integer;

begin

// preenche dos campos de uma ficha

Ficha.Proprietario:= Edit1.Text;

Ficha.Endereco:= Edit2.Text;

Ficha.NomeAnimal:= Edit3.Text;

Ficha.Nascimento:= StrToInt(Edit4.Text);

Ficha.Classificacao:= RadioGroup1.ItemIndex;

// posiciona o ponteiro no registro informado

reg := StrToInt(Edit5.Text);

Seek(arq, reg);

// grava a ficha no arquivo

Write(arq, Ficha);

end;

end.


Note que o tipo de dados heterogêneos não é representado no fluxograma, embora os campos tenham sido preenchidos e exibidos isoladamente.

Também deve ser notado que a formatação do objeto StringGrid1 é omitida do fluxograma do procedimento FormCreate por se tratar de uma particularidade da linguagem Object Pascal.


Referências BÖHM, C.; JACOPINI, G. Flow diagrams, Turing machines and languages with only two formation rules. In: Communications of the ACM, v. 9, v. 5, p. 366-371, maio 1966. Dicionário Houaiss da língua Portuguesa. Disponível em: <www.houaiss.uol.com.br>. Acesso em: 13.09.06 INTERNATIONAL ORGANIZATION FOR STANDARDIZATION. ISO 5807: information processing – documentation symbols and conventions for data, program and system flowcharts, program network charts and system resources charts. 1985. MANZANO, J. A. N. G. Revisão e discussão da norma ISO 5807 – 1985 (E) proposta para padronização formal da representação gráfica da linha de raciocínio lógico utilizada no desenvolvimento da programação de computadores a ser definida no Brasil. Thesis Revista Eletrônica, São Paulo, v.1, n.1, p1-31, 1o Semestre 2004. Disponível em: <http://www.cantareira.br/thesis/v1n1/navarro.pdf>. Acesso em 14 set. 2006. SOUZA, M. A. F.; SOARES, M. V.; GOMES, M. M.; CONCÍLIO, R., Algoritmos e lógica de programação. São Paulo, SP : Thomson Learning, 2004, 214p. ______. Introdução à linguagem Pascal. São Caetano do Sul, SP : EEM, 2001, 97p. Apostila. ZAMBONI, L. C.; BARROS, E. A. R.; GRINKRAUT, M. L.; PAMBOUKIAN, S. V. D., Delphi para universitários. 2 Ed, São Paulo, SP : Páginas & Letras, 2000, 494p.

341sicos com o microsoft visio...

Documents