algoritmo e programaÇÃo-------------------------------------------------------...

Algoritmos e Programação _ Departamento de Informática

_________________________________________________________________________________ Professores: Ivo Mário Mathias e Marcelo Ferrasa Pág: i

Sumário

ALGORITMO E PROGRAMAÇÃO --------------------------------------------------------- 6

1 ALGORITMO ----------------------------------------------------------------------- 6

1.1 Ação------------------------------------------------------------------------------- 6

1.2 Automação ---------------------------------------------------------------------- 6

1.3 Repetibilidade ----------------------------------------------------------------- 6

1.4 Outras Definições ------------------------------------------------------------ 6

2 PROGRAMAÇÃO ------------------------------------------------------------------ 6

3 LINGUAGEM DE PROGRAMAÇÃO (SOFTWARE) ------------------------------- 7

3.1 Linguagem de Máquina – primeira geração – 1GL ----------------- 7

3.2 Linguagem Assembler/Montadora – segunda geração – 2GL -- 7

3.3 Linguagens de Alto Nível – terceira geração – 3GL --------------- 7

3.3.1 Histórico ------------------------------------------------------------------------- 7

3.4 Linguagens de quarta geração – 4GL ---------------------------------- 9

3.4.1 Histórico ------------------------------------------------------------------------- 9

3.5 Linguagens de quinta geração – 5GL -------------------------------- 10

3.5.1 Histórico ----------------------------------------------------------------------- 10

3.6 Compiladores ---------------------------------------------------------------- 10

3.7 Interpretadores -------------------------------------------------------------- 10

3.8 Software ----------------------------------------------------------------------- 11

4 FORMAS DE REPRESENTAÇÃO DE ALGORITMOS -------------------------- 11

4.1 Descrição Narrativa -------------------------------------------------------- 11

4.2 Fluxograma Convencional ----------------------------------------------- 11

4.3 Pseudocódigo - Linguagem Estruturada - Portugol ------------- 13

5 TIPOS DE DADOS --------------------------------------------------------------- 16

5.1 Classificação dos dados de acordo com o tipo ------------------ 16

5.1.1 Dados Numéricos ----------------------------------------------------------- 16

5.1.2 Dados Literais (Alfanuméricos) ---------------------------------------- 17

5.1.3 Dados Lógicos -------------------------------------------------------------- 17


_________________________________________________________________________________

Professores: Ivo Mário Mathias e Marcelo Ferrasa ii

5.1.4 Resumo ------------------------------------------------------------------------ 17

6 VARIÁVEIS ----------------------------------------------------------------------- 18

6.1 Representação da Informação ------------------------------------------ 18

6.1.1 Bit -------------------------------------------------------------------------------- 18

6.1.2 Byte (octeto) ------------------------------------------------------------------ 18

6.1.3 Nybble -------------------------------------------------------------------------- 18

6.1.4 Kilobyte (KByte) ------------------------------------------------------------- 18

6.1.5 Megabyte (MByte)----------------------------------------------------------- 19

6.1.6 Gigabyte (GByte) ------------------------------------------------------------ 19

6.1.7 Terabyte (TByte) ------------------------------------------------------------ 19

6.1.8 Petabyte (PByte) ------------------------------------------------------------ 19

6.2 Armazenamento de dados na Memória ------------------------------ 19

6.2.1 Armazenamento de Dados do Tipo Literal ------------------------- 20

6.2.2 Armazenamento de Dados do Tipo Lógico------------------------- 20

6.2.3 Armazenamento de Dados do Tipo Inteiro ------------------------- 20

6.2.4 Armazenamento de Dados do Tipo Real ---------------------------- 20

6.3 Conceito e Utilidade de Variáveis ------------------------------------- 20

6.4 Declaração de variáveis em Algoritmos ----------------------------- 21

6.5 Mapeamento de variáveis na memória ------------------------------- 21

7 EXPRESSÕES ------------------------------------------------------------------- 25

7.1 Operadores ------------------------------------------------------------------- 26

7.2 Tipos de Expressões ------------------------------------------------------ 26

7.2.1 Expressões Aritméticas -------------------------------------------------- 26

7.2.2 Expressões Lógicas ------------------------------------------------------- 27

7.2.3 Expressões Literais -------------------------------------------------------- 29

7.3 Avaliação de Expressões ------------------------------------------------ 29

7.4 Prioridade (precedência) entre todos os operadores ----------- 30

8 INSTRUÇÕES PRIMITIVAS ------------------------------------------------------ 30

8.1 Instrução Primitiva de Atribuição -------------------------------------- 31

8.2 Instrução Primitiva de Saída de Dados ------------------------------ 32

8.3 Instrução Primitiva de Entrada de Dados --------------------------- 32


_________________________________________________________________________________

Professores: Ivo Mário Mathias e Marcelo Ferrasa iii

9 TESTE DE MESA ---------------------------------------------------------------- 34

10 ESTRUTURAS DE CONTROLE DO FLUXO DE EXECUÇÃO ------------------ 35

10.1 Estrutura Sequencial ------------------------------------------------------ 35

10.2 Estruturas de Decisão ----------------------------------------------------- 35

10.2.1 Estruturas de Decisão do tipo Se ------------------------------------- 35

10.2.2 Estruturas de Decisão do tipo Escolha ------------------------------ 36

10.3 Estruturas de Repetição -------------------------------------------------- 37

10.3.1 Laços Contados ------------------------------------------------------------- 37

10.3.2 Laços Condicionados ----------------------------------------------------- 37

10.4 Aninhamentos --------------------------------------------------------------- 38

11 VARIÁVEIS INDEXADAS -------------------------------------------------------- 39

11.1 Declaração de Variáveis Indexadas ----------------------------------- 39

11.2 Operações Básicas com Variáveis Indexadas --------------------- 40

11.2.1 Atribuição --------------------------------------------------------------------- 40

11.2.2 Leitura -------------------------------------------------------------------------- 40

11.2.3 Escrita -------------------------------------------------------------------------- 40

11.3 Aplicação de conjuntos em algoritmos ------------------------------ 41

11.3.1 Método de Pesquisa Sequencial (ou Linear) ----------------------- 42

11.3.2 Método de Pesquisa Binária -------------------------------------------- 44

11.3.3 Método da Bolha de Classificação/Ordenação (Bubble Sort) 46

12 SUBALGORITMOS --------------------------------------------------------------- 48

12.1 Mecanismos e Funcionamento ----------------------------------------- 48

12.2 Declaração de Subalgoritmos ------------------------------------------ 49

12.3 Definição de Subalgoritmos --------------------------------------------- 49

12.3.1 Funções ------------------------------------------------------------------------ 50

12.3.2 Procedimentos -------------------------------------------------------------- 51

12.4 Variáveis Globais e Locais ---------------------------------------------- 52

12.5 Parâmetros-------------------------------------------------------------------- 52

12.6 Mecanismos de Passagem de Parâmetros ------------------------- 53

12.6.1 Passagem de Parâmetros por Valor ---------------------------------- 53

12.6.2 Passagem de Parâmetros por Referência -------------------------- 54


_________________________________________________________________________________

Professores: Ivo Mário Mathias e Marcelo Ferrasa iv

13 RECURSIVIDADE ---------------------------------------------------------------- 55

13.1 Uso de Recursão na Solução de Problemas ----------------------- 55

13.2 Quando Aplicar Recursão ------------------------------------------------ 59

14 PONTEIROS---------------------------------------------------------------------- 59

14.1 Características no uso de ponteiros --------------------------------- 59

14.2 Ponteiros em Linguagem C ---------------------------------------------- 60

14.2.1 Variáveis Ponteiro ---------------------------------------------------------- 60

14.2.2 Operadores unários de ponteiros ------------------------------------- 60

14.2.3 Operações com ponteiros ----------------------------------------------- 60

15 VARIÁVEIS COMPOSTAS HETEROGÊNEAS (AGREG. HETEROGÊNEOS) 63

15.1 Tipos definidos pelo programador ------------------------------------ 63

15.2 Estruturas Registros ------------------------------------------------------- 63

15.2.1 Declaração -------------------------------------------------------------------- 64

15.2.2 Manipulação ------------------------------------------------------------------ 64

15.3 Registro de Conjuntos ---------------------------------------------------- 64

15.3.1 Manipulação ------------------------------------------------------------------ 65

15.4 Conjunto de Registros ---------------------------------------------------- 66

16 ARQUIVOS ----------------------------------------------------------------------- 69

16.1 Tipos de arquivos ---------------------------------------------------------- 69

16.1.1 Sequencial -------------------------------------------------------------------- 69

16.1.2 Direto (Randômico) -------------------------------------------------------- 69

16.2 Tratamento de Arquivos em Linguagem C ------------------------- 69

16.3 Comandos em pseudicódigo para manipulação de Arquivos 69

17 PROGRAMAÇÃO ORIENTADA A OBJETO------------------------------------- 72

17.1 Objeto -------------------------------------------------------------------------- 72

17.1.1 Características fundamentais de um objeto: ---------------------- 74

17.1.2 Enfoque estruturado x Enfoque Orientado a Objetos: ---------- 75

17.2 Classes------------------------------------------------------------------------- 75

17.2.1 Declaração de Classes em Java --------------------------------------- 77

17.3 Métodos------------------------------------------------------------------------ 78

17.3.1 Elementos de um método ------------------------------------------------ 79


_________________________________________________________________________________

Professores: Ivo Mário Mathias e Marcelo Ferrasa v

17.3.2 Descrição de um método ------------------------------------------------- 79

17.3.3 Declaração de métodos em Java -------------------------------------- 80

17.3.4 Escopo de Variáveis ------------------------------------------------------- 84

17.3.5 Criando Objetos ------------------------------------------------------------- 87

17.3.6 Método Construtor --------------------------------------------------------- 89

17.4 Herança ------------------------------------------------------------------------ 91

18 FASES DE DESENVOLVIMENTO DE UM PROGRAMA ------------------------ 94

18.1 Fase de Definição (O que?)---------------------------------------------- 94

18.2 Fase de Desenvolvimento (Como?)----------------------------------- 94

18.2.1 Teste de Software ---------------------------------------------------------- 95

18.3 Fase de Manutenção (mudança) --------------------------------------- 95


_________________________________________________________________________________

Professores: Ivo Mário Mathias e Marcelo Ferrasa 6

ALGORITMO E PROGRAMAÇÃO

1 ALGORITMO

É a descrição de um conjunto de ações que, obedecidas, resultam numa su-

cessão finita de passos, atingindo um objetivo.

1.1 AÇÃO

É um acontecimento que a partir de um estado inicial, após um período de

tempo finito, produz um estado final previsível e bem definido.

1.2 AUTOMAÇÃO

É o processo em que uma tarefa deixa de ser desempenhada pelo homem e

passa a ser realizada por máquinas, sejam estas dispositivos mecânicos, eletrôni-

cos (como computadores) ou de natureza mista.

1.3 REPETIBILIDADE

É necessário que seja especificado com clareza e exatidão o que deve ser

realizado em cada uma das fases do processo a ser automatizado, bem como a se-

quência em que estas fases devem ser realizadas.

1.4 OUTRAS DEFINIÇÕES

• ALGORITMO – é a especificação de uma sequência ordenada de passos que

deve ser seguida para realização de uma tarefa garantindo a sua repetibilidade.

• ALGORITMO – é uma sequência de passos que visam atingir um objetivo bem

definido.

2 PROGRAMAÇÃO

O conceito central da programação é o de algoritmo. Programar é basicamen-

te construir algoritmos. Segundo Wirth: Programas são formulações concretas de

algoritmos abstratos, baseados em representações e estruturas específicas de da-

dos. Um programa pode ser visto como uma codificação de um algoritmo em uma

determinada Linguagem de Programação, para execução pelo computador.


_________________________________________________________________________________


3 LINGUAGEM DE PROGRAMAÇÃO (SOFTWARE)

3.1 LINGUAGEM DE MÁQUINA – PRIMEIRA GERAÇÃO – 1GL

Os computadores só podem executar os programas diretamente em Lingua-

gem de Máquina, que é um conjunto de instruções capazes de ativar diretamente os

dispositivos eletrônicos do computador. Os computadores possuem diferentes co-

mandos implementados em seu processador e esses são acessados em forma nu-

mérica (binária ou hexadecimal), o que torna pouco expressivo para leitores huma-

nos um programa em Linguagem de Máquina, pois há necessidade de saber o signi-

ficado específico de cada número.

3.2 LINGUAGEM ASSEMBLER/MONTADORA – SEGUNDA GERAÇÃO – 2GL

Diante das dificuldades apresentadas pela Linguagem de Máquina, surgiu a

ideia da linguagem simbólica, onde palavras (mnemônicos) como LOAD, STORE,

MOVE, COMPARE, ADD, SUBTRACT, MULTIPLY e DIVIDE, são usadas como

equivalentes diretos das instruções binárias. É a linguagem de nível imediatamente

acima da linguagem de máquina, baixo nível, em que um programa chamado

montador, escrito em Linguagem de Máquina, organiza as palavras e as traduz para

forma binária, que é armazenada em bancos de dados chamados bibliotecas

(libraries).

3.3 LINGUAGENS DE ALTO NÍVEL – TERCEIRA GERAÇÃO – 3GL

A partir da Linguagem Assembler, onde um comando dessa corresponde a

um comando em Linguagem de Máquina, se estabeleceu a relação de um comando

simbólico para vários comandos em Linguagem de Máquina.

São linguagens de programação projetadas para serem facilmente entendi-

das pelo ser humano, consideradas procedurais e estruturadas, em que a maioria

dessas linguagens suporta o conceito de programação estruturada.

3.3.1 Histórico

• 1957 - FORTRAN (Formula Translation): fórmulas matemáticas, natureza técnica e ci-

entífica.

• 1959 - COBOL (Common Business Oriented Language): comercial, uso geral.


_________________________________________________________________________________


• 1964 - BASIC (Begineers All-Purpose Symbolic Instruction Code): inicialmente, ser uma

linguagem mais simples que o Fortran, porém evoluiu sem um padrão definido e pas-

sou a ser a linguagem mais utilizada em microcomputadores, de uso geral.

• 1968 - PASCAL (homenagem ao matemático francês): voltada, para o ensino, mas

também de uso geral.

• 1972 - C (A,B e C ultimo resultado): Uso geral, nível médio.

Observação - linguagem C: criada na década de 70, por Dennis Ritchie, nos

laboratórios Bell. Para tanto, ele utilizou o sistema operacional Unix e a linguagem

BCPL. Baseado nessa linguagem, outro pesquisador, chamado Ken Thompson (que

também trabalhou na criação de C) havia criado a linguagem B, que por sua vez foi

influenciada pela linguagem BCPL criada por Martin Richards. Como a linguagem

de Richie foi posterior à linguagem B, recebeu o nome de C.

A linguagem C é estruturada, e considerada de nível médio, possui portabil i-

dade do código fonte e um programa objeto muito eficiente, rápido e compacto.

Alguns sistemas computacionais escritos em C: Unix e Linux, parte do Windows

e seus aplicativos, Delphi, Turbo Pascal, Cbuilder, etc.

Comparativo entre códigos:


_________________________________________________________________________________


3.4 LINGUAGENS DE QUARTA GERAÇÃO – 4GL

Uma das principais características dessas linguagens e a de gerar código au-

tomaticamente para a produção de programas de computadores aplicando a técnica

RAD (Rapid Application Development). Essa técnica possibilita obter uma maior

otimização dos códigos dos programas e maior rapidez de desenvolvimento por

meio de uma IDE (Integrated Development Environment), geralmente em ambiente

visual utilizando-se dos recursos gráficos do sistema operacional, como o Windows.

Exemplos: C Builder, Delphi, Visual Basic, etc.

Nessa geração de linguagens também se encontram as linguagens orienta-

das à objetos o que torna possível a reutilização de partes do código para outros

programas.

Uma linguagem considerada 4GL é a linguagem SQL (Structured Query

Language), sendo um padrão para manipulação e consulta de bancos de dados

relacional, também usada em conjunto com as linguagens de 3GL.

3.4.1 Histórico

• Java é uma linguagem de programação orientada a objeto desenvolvida na

década de 90 por uma equipe de programadores chefiada por James Gosling, na

empresa Sun Microsystems. Diferentemente das linguagens convencionais, que

são compiladas para código nativo, a linguagem Java é compilada para um

bytecode que é executado por uma máquina virtual.

• PHP (PHP: Hypertext Processor) é uma linguagem de programação de

computadores interpretada, livre e muito utilizada para gerar conteúdo dinâmico

na Web (HTML e PHP), desenvolvida em meados de 1994.

• Python: de alto nível, orientada a objetos e multiplataforma; possui sintaxe sim-

ples e tipagem de dados dinâmica.

• Delphi: reúne um compilador, IDE e a linguagem de programação. Utiliza uma

biblioteca Objetc Pascal para desenvolvimento de aplicativos multiplataforma.

• Javascript: linguagem de scripts para validação de formulários no lado cliente

de uma aplicação cliente-servidor Web.


_________________________________________________________________________________


3.5 LINGUAGENS DE QUINTA GERAÇÃO – 5GL

Nessa geração são consideradas as linguagens orientadas à Inteligência Ar-

tificial (IA). Exemplo: LISP, Prolog.

3.5.1 Histórico

• LISP (LISt Processing) a lista é a estrutura de dados fundamental dessa

linguagem. Tanto os dados como o programa são representados como listas, o

que permite que a linguagem manipule o código fonte como qualquer outro tipo

de dados. A linguagem LISP é interpretada, em que o usuário digita expressões

em uma linguagem formal definida e recebe como retorno a avaliação de sua

expressão.

• PROLOG (PROgramming in LOGic) é uma linguagem de programação lógica e

declarativa. O propósito dessa linguagem é criar programas para tradução de

linguagem natural (como inglês ou português).

3.6 COMPILADORES

São programas especialmente projetados para traduzir programas escritos

em linguagem de alto nível (programa fonte) para linguagem de máquina, gerando

um novo programa chamado programa objeto, após esta operação o código objeto

deve passar por mais uma etapa que é a linkedição, que consiste em gerar um pro-

grama executável (módulo de carga). O programa linkeditor tem também a finalida-

de de juntar diversos programas objeto em um único programa (módulo de carga). O

compilador é específico a cada linguagem, ou seja, só pode compilar programas es-

critos na linguagem para a qual foi preparado, e ao efetuar a compilação detecta e

emite mensagens sobre os erros no uso da linguagem (erros de sintaxe, uso incor-

reto de comandos, etc.), não gerando o programa compilado, ou seja, o programa

objeto.

3.7 INTERPRETADORES

São programas especialmente projetados para traduzir (interpretar) progra-

mas escritos em linguagem de alto nível para linguagem de máquina, durante a


_________________________________________________________________________________


execução, ou seja não é gerado um novo programa, o próprio texto do programa é

utilizado. Os Interpretadores são específicos a cada linguagem e durante a execu-

ção de um programa verifica a existência de algum erro no uso da linguagem, caso

haja, interrompe a execução emitindo uma mensagem apontando o erro. A execu-

ção de um programa interpretado é mais lenta em relação a um compilado.

3.8 SOFTWARE

O Software está dividido em Software de Sistema e Software de Aplicação, e

o Software de Sistema subdivide-se em Software do Sistema Operacional e Softwa-

re de Linguagens.

4 FORMAS DE REPRESENTAÇÃO DE ALGORITMOS

4.1 DESCRIÇÃO NARRATIVA

Representação dos algoritmos diretamente em linguagem natural. Pouco usa-

da na prática porque o uso da linguagem natural muitas vezes causa má interpreta-

ção, ambiguidades e imprecisões. Exemplo: uma instrução como, "Afrouxar ligeira-

mente um parafuso", necessitaria de uma instrução mais precisa como, "Afrouxar o

parafuso, girando 30º no sentido anti-horário".

4.2 FLUXOGRAMA CONVENCIONAL

É uma representação gráfica de algoritmos onde formas geométricas diferen-

tes implicam ações (instruções, comandos) distintos. Tal propriedade facilita o en-

tendimento das ideias contidas nos algoritmos.

• Forma intermediária entre a descrição narrativa e o pseudocódigo (subitem se-

guinte), mas é menos imprecisa que a primeira e no entanto, não se preocupa

com detalhes de implementação do programa como tipo das variáveis usadas

(item futuro).

• Preocupa-se com detalhes de nível físico da implementação do algoritmo como:

distinguir dispositivos onde ocorrem as operações de entrada e saída de dados.


_________________________________________________________________________________


Principais formas geométricas usadas em fluxogramas:

= Início e Final do Fluxograma

= Operação de Entrada de dados

= Operação de saída de dados

= Operações de atribuição e chamada

ou retorno de subalgoritmo.

= Desvio condicional (decisão)


_________________________________________________________________________________


Exemplo: Cálculo da média de duas notas de um aluno sob a forma de um fluxo-

grama.

4.3 PSEUDOCÓDIGO - LINGUAGEM ESTRUTURADA - PORTUGOL

É uma forma de representação de algoritmos rica em detalhes, como a defini-

ção dos tipos de variáveis usadas em linguagens de programação e assemelha-se

bastante a forma com que os programas são escritos.

Início

N1,N2

Média := (N1+N2)/2

Mé-

dia>=77

"Aprovado"

"Reprovado" Fim.

.V.

.F.


_________________________________________________________________________________


Forma geral de representação de um algoritmo em pseudocódigo:

Algoritmo <nome_do_algoritmo>

Var <declaração_de_variáveis_globais>

<declaração_dos_subalgoritmos>

Início

Var <declaração_de_variáveis_locais>

<corpo_do_algoritmo>

Fim.

Onde:

• Algoritmo é uma palavra que indica o início da definição de um algoritmo em

forma de pseudocódigo;

• <nome_do_algoritmo> é um nome simbólico dado ao algoritmo com a finalida-

de de distingui-lo dos demais;

• <declaração_de_variáveis> consiste em uma porção opcional onde são decla-

radas as variáveis locais/globais usadas no algoritmo principal e eventualmente

nos subalgoritmos;

• <subalgoritmos> consiste de uma porção opcional do pseudocódigo onde são

definidos os subalgoritmos.

• Início e Fim são as palavras que respectivamente delimitam o início e término

do conjunto de instruções do corpo do algoritmo.


_________________________________________________________________________________


Exemplo: Cálculo da média de duas notas de um aluno em pseudocódigo.

Algoritmo Média;

Início

Var

real: N1, N2, Média;

Leia N1, N2;

Média = (N1 + N2) / 2;

Se Média >= 7

Então

Escreva "Aprovado";

Senão

Escreva "Reprovado";

Fim_se;

Fim.


_________________________________________________________________________________


5 TIPOS DE DADOS

Todo o trabalho realizado por um computador é baseado na manipulação das

informações contidas em sua memória. De um modo geral estas informações podem

ser classificadas em dois tipos:

• Instruções - que comandam o funcionamento da máquina e determinam a ma-

neira como devem ser tratados dos dados.

• Dados - que correspondem à porção das informações a serem processadas pelo

computador.

5.1 CLASSIFICAÇÃO DOS DADOS DE ACORDO COM O TIPO

5.1.1 Dados Numéricos

• Conjunto dos números naturais representados por N;

N = {0,1,2,3,4,5.....}

• Conjunto dos números inteiros (Z);

Z = {...,-4,-3,-2,-1,0,1,2,3,4,...}

• Conjunto dos números fracionários (Q);

Q = {p/q | p,q pertencem a Z}

• Conjunto dos números reais (R);


_________________________________________________________________________________


Do ponto de vista do computacional (algorítmico) os dados numéricos repre-

sentáveis num computador são divididos em apenas duas classes: inteiros e reais.

5.1.2 Dados Literais (Alfanuméricos)

Constituído por uma sequência de caracteres contendo letras, dígitos e/ou

símbolos especiais. Este tipo de dados é também chamado de alfanumérico, ca-

deia (ou cordão) de caracteres ou ainda do inglês string.

Usualmente, os dados literais são representados nos algoritmos e nas lin-

guagens de programação pela coleção de caracteres, delimitada em seu início e

termino com o caractere aspas (") ou aspas simples - plicas (').

O comprimento ou tamanho de um dado literal é dado pelo número de ca-

racteres nele contido (inclusive espaços em branco).

5.1.3 Dados Lógicos

A existência deste tipo de dado de certo modo é um reflexo da maneira como

os computadores funcionam. São também chamados de booleanos, em função da

significativa contribuição BOOLE à área da lógica matemática.

São usados para representar dois únicos valores lógicos possíveis: Verda-

deiro/Falso - Sim/Não - 1/0 - True/False.

Exemplo de representação a ser adotada nos algoritmos:

.V. - valor lógico verdadeiro;

.F. - valor lógico falso;

5.1.4 Resumo


_________________________________________________________________________________


6 VARIÁVEIS

Uma variável é uma posição nomeada de memória, que é usada para guardar

um valor que pode ser modificado pelo programa. A todo o momento durante a exe-

cução de um programa os computadores estão manipulando informações represen-

tadas pelos diferentes tipos de dados. Para que não se "esqueça" das informações,

o computador precisa guardá-las em sua memória.

6.1 REPRESENTAÇÃO DA INFORMAÇÃO

6.1.1 Bit

Unidade básica da informação é o BIT (BInary digiT), é a porção de informa-

ção fornecida por um verdadeiro ou falso, uma resposta sim/não, como uma chave

liga/desliga, simbolicamente os dígitos 0 e 1 são utilizados.

6.1.2 Byte (octeto)

BYTE (BinarY TErm), constituído por um conjunto de oito bits. Desta forma é

possível representar 256 (28) combinações diferentes.

6.1.3 Nybble

Meio byte, constituído por 4 bits.

6.1.4 Kilobyte (KByte)

Um kbyte equivale a 1024 octetos ou bytes (8192 bits). O fato de correspon-

der a 1024 e não a 1000 se deve a que 1 kbyte é igual a 210 (base do sistema biná-

rio elevada a décima potência); além disso, essa correspondência faz com que o


_________________________________________________________________________________


kbyte seja múltiplo de 8.

6.1.5 Megabyte (MByte)

Equivale a 1.048.576 de bytes (octetos), ou seja 220 (base do sistema binário

elevada a vigésima potência), para representação de grande volume de memória.

6.1.6 Gigabyte (GByte)

Equivale a 1.073.741.824 bytes - 230 (base do sistema binário elevada a tri-

gésima potência).

6.1.7 Terabyte (TByte)

Equivale a 1.099.511.627.776 bytes - 240 (base do sistema binário elevado a

quadragésima potência).

6.1.8 Petabyte (PByte)

Equivale a 1.125.899.906.842.624 bytes - 250 (base do sistema binário eleva-

do a quinquagésima potência).

6.2 ARMAZENAMENTO DE DADOS NA MEMÓRIA

A memória de um computador pode ser vista como um conjunto ordenado de

células (bytes) cada uma identificada por um número inteiro positivo distinto, conhe-

cido como endereço (ponteiro).

Figura 1. Representação da memória RAM.


_________________________________________________________________________________


6.2.1 Armazenamento de Dados do Tipo Literal

Como cada dado do tipo literal é representado por um byte e como é possível

representar 256 (28) combinações diferentes surgiu a ideia de associar cada carac-

ter a um número (código) diferente variando de 0 a 255 (256 possibilidades). Essa

convenção é representada na forma de uma tabela de mapeamento de caracteres e

números. O padrão universalmente aceito é o ASCII-(American Standard Code for

Information Interchange/Código Padrão Americano para Intercâmbio de informa-

ções).

Desse modo como cada informação do tipo literal é constituído por um byte, e

como seu tamanho é definido pelo comprimento (quantidade de caracteres/bytes),

para guardar um literal na memória do computador deve-se alocar (reservar) um es-

paço contíguo de memória igual ao seu comprimento.

6.2.2 Armazenamento de Dados do Tipo Lógico

São armazenados em um byte.

6.2.3 Armazenamento de Dados do Tipo Inteiro

Na maioria das linguagens de programação são armazenados em dois bytes

(28 x 28 = 216) 65536 possibilidades

(-32767, -32766, ..., -2,-1,0,1,2,..., 32766, 32767) – com sinal.

(0,1,2,..., 65534, 65535) – sem sinal.

Contudo existem linguagens de programação que admitem representar dados

do tipo inteiro em 4 ou 8 bytes, ditos inteiros longos ou estendidos.

6.2.4 Armazenamento de Dados do Tipo Real

Normalmente são armazenados em 4 bytes, porém existem linguagens de

programação que admitem o real estendido com 8 ou 16 bytes.

(28 x 28 x 28 x 28 = 232) 4.294.967.296 possibilidades

6.3 CONCEITO E UTILIDADE DE VARIÁVEIS

Variável é uma entidade destinada a guardar uma informação.

Basicamente uma variável possui três atributos:

• Nome (identificação) - de uma forma geral as regras para criação de no-

mes de variáveis são as seguintes: deve começar necessariamente com


_________________________________________________________________________________


uma letra e não deve conter nenhum símbolo especial exceto a sublinha

(_).

• Tipo de dado associado a mesma - inteiro, real, literal ou lógico.

• Informação por ela guardada - único elemento que sofrerá alteração du-

rante a execução de um programa.

6.4 DECLARAÇÃO DE VARIÁVEIS EM ALGORITMOS

Todas as variáveis utilizadas em algoritmos e programas devem ser definidas

antes de serem utilizadas, para permitir que o compilador ou interpretador reserve

espaço na memória para as mesmas.

Forma como declarar variáveis em algoritmos:

VAR <tipo_da_variável> : <nome_da_variável>;

ou

VAR <tipo_das_variáveis> : <lista_de_variáveis>;

Sintaxe:

• A palavra-chave VAR deverá estar presente e será utilizada uma única

vez na declaração de um conjunto ou de uma ou mais variáveis;

• Numa mesma linha poderão ser definidas uma ou mais variáveis do mes-

mo tipo; Para tal, deve-se separar os nomes das mesmas por vírgulas;

• Variáveis de tipos diferentes devem ser declaradas em linhas diferentes.

Exemplo (formato C):

VAR literal : NOME[10];

inteiro : IDADE;

real : SALÁRIO;

lógico : TEM_FILHOS;

6.5 MAPEAMENTO DE VARIÁVEIS NA MEMÓRIA

O computador não é capaz de trabalhar diretamente com nomes simbólicos

de variáveis, só consegue tratar de células de memória por meio do conhecimento

de seus endereços (ponteiros). Para intermediar esta situação o compilador ou in-

terpretador monta uma tabela de símbolos. Exemplo:


_________________________________________________________________________________


Nome simbólico Posição inicial Tipo de dado

NOME 0 LITERAL[10]

IDADE 10 INTEIRO

SALÁRIO 12 REAL

TEM_FILHOS 16 LÓGICO

Exercícios:

Na lista a seguir, assinale com ( V ) os nomes de variáveis válidos e com ( N )

os inválidos:

( ) abc ( ) 3abc ( ) a

( ) 123a ( ) _a ( ) acd1

( ) _ ( ) Aa ( ) 1

( ) A123 ( ) _1 ( ) A0123

( ) a123 ( ) _a123 ( ) b312

( ) AB CDE ( ) guarda-chuva ( ) etc...


_________________________________________________________________________________


( V ) abc ( N ) 3abc ( V ) a

( N ) 123a ( V ) _a ( V ) acd1

( N ) _ ( V ) Aa ( N ) 1

( V ) A123 ( V ) _1 ( V ) A0123

( V ) a123 ( V ) _a123 ( V ) b312

( N ) AB CDE ( N ) guarda-chuva ( N ) etc...

Dadas as declarações de variáveis a seguir (formato Pascal), monte as tabelas

de símbolos correspondentes, como seria realizado por um compilador:

a)

VAR A,B,C : REAL;

DELTA : REAL;

POSITIVO : LOGICO;

RAIZ1, RAIZ2 : REAL;

b)

VAR X, Y : INTEIRO;

NOME, PROFISSAO : LITERAL[20];

RUA : LITERAL[30];

NUMERO : INTEIRO;

RENDA : REAL;


_________________________________________________________________________________


a)


A 0 REAL

B 4 REAL

C 8 REAL

DELTA 12 REAL

POSITIVO 16 LÓGICO

RAIZ1 17 REAL

RAIZ2 21 REAL

b)


X 0 INTEIRO

Y 2 INTEIRO

NOME 4 LITERAL[20]

PROFISSAO 24 LITERAL[20]

RUA 44 LITERAL[30]

NUMERO 74 INTEIRO

RENDA 76 REAL

Exemplos em linguagens de programação C e Pascal

// linguagem C

float a,b,c;

float delta;

char positivo;

float raiz1,raiz2;

int x,y;

float a,b,c,delta,raiz1,raiz2,renda;

char positivo;

int x,y,numero;

char nome[20];

char rua[30];


_________________________________________________________________________________


char nome[20];

char rua[30];

int numero;

float renda;

{ linguagem Pascal}

var

a,b,c: real;

delta: real;

positivo: boolean;

raiz1,raiz2: Real;

x,y: integer;

nome: string[20];

rua: string[30];

numero: integer;

renda: real;

var

a,b,c,delta,raiz1,raiz2: real;

positivo: boolean;

x,y,numero: integer;

nome: string[20];

rua: string[30];

7 EXPRESSÕES

O conceito de expressão em termos computacionais esta intimamente ligado

ao conceito de expressão (ou fórmula) matemática, onde, um conjunto de variáveis

e constantes numéricas relacionam-se por meio de operadores aritméticos compon-

do uma fórmula que, uma vez avaliada, resulta num valor. Ou ainda, uma expres-

são é uma combinação de variáveis, constantes e operadores, e que, uma vez ava-

liada, resulta num valor.

Exemplo: Fórmula de cálculo da área de um triângulo.

ÁREA = 0,5 * (B * H);

Onde:

B, H → variáveis que respectivamente correspondem a base e altura;

0,5 → constante;

* → operador de multiplicação.


_________________________________________________________________________________


7.1 OPERADORES

São elementos funcionais que atuam sobre os operandos.

De acordo com o número de operandos podem ser classificados em:

• Binários - quando atuam sobre dois operandos. Exemplo os operadores

das operações aritméticas básicas (soma, subtração, multiplicação e divi-

são).

• Unários - quando atuam sobre um único operando. Exemplo o sinal de (–)

na frente de um número, cuja função é inverter seu sinal.

Outra classificação é feita considerando-se o tipo de dado de seus operandos

e do valor resultante de sua avaliação, podendo ser: Aritméticos, lógicos e lite-

rais.

Existindo ainda um caso especial que são os operadores relacionais, que

permitem comparar pares de operandos de tipos iguais, resultando sempre num va-

lor lógico.

7.2 TIPOS DE EXPRESSÕES

Classificadas de acordo com o tipo de valor resultante de sua avaliação.

7.2.1 Expressões Aritméticas

São aquelas cujo resultado da avaliação é do tipo numérico, seja ele inteiro

ou real e somente o uso de operadores aritméticos e variáveis numéricas são permi-

tidos.

No caso das variáveis numéricas os tipos podem ser inteiro ou real e ambos

podem ser combinados. Para o caso de uma expressão com tipos inteiros o resulta-

do da avaliação também será do tipo inteiro, quando os dois tipos são combinados o

resultado da avaliação é do tipo real.


_________________________________________________________________________________


7.2.1.1 Operadores aritméticos

Operador Tipo Operação Precedência

+ Binário Adição 4

– Binário Subtração 4

* Binário Multiplicação 3

/ Binário Divisão 3

MOD Binário Resto de divisão 3

** ou ^ Binário Exponenciação

Potenciação

2

SQRT Unário Raiz Quadrada 2

+ Unário Manutenção de sinal 1

– Unário Inversão de sinal 1

Observação: Exponenciação em Linguagem C:

x = 24 x = 2 ^ 4 x = pow(2,4) ( #include <math.h> )

7.2.2 Expressões Lógicas

São aquelas cujo resultado da avaliação é um valor lógico (.V. ou .F.).

7.2.2.1 Operadores lógicos

Operador Tipo Operação Precedência

.OU. Binário Disjunção 3

.E. Binário Conjunção 2

.NÃO. Unário Negação 1


_________________________________________________________________________________


7.2.2.2 Tabela-verdade dos operadores lógicos

A B .NÃO. A .NÃO. B A .OU. B A .E. B

.V. .V. .F. .F. .V. .V.

.V. .F. .F. .V. .V. .F.

.F. .V. .V. .F. .V. .F.

.F. .F. .V. .V. .F. .F.

A B .NÃO. A .NÃO. B A .OU. B

( )

A .E. B

( )

1 1 0 0 1 1

1 0 0 1 1 0

0 1 1 0 1 0

0 0 1 1 0 0

Analogia com Circuitos Elétricos - Interruptores:

Em Paralelo Em Série

1 1

.OU. .E.

0 0


_________________________________________________________________________________


7.2.2.3 Operadores relacionais

São aqueles usados para efetuar comparações e só podem ser feitas entre

variáveis de um mesmo tipo cujo resultado é sempre um valor lógico.

Tabela dos operadores relacionais em pseudocódigo:

Operador Comparação Precedência

= Igual 2

<> Diferente 2

< Menor 1

<= Menor ou igual 1

> Maior 1

>= Maior ou igual 1

7.2.3 Expressões Literais

São aquelas cujo resultado da avaliação é um valor literal. Os tipos de ope-

radores variam de uma linguagem de programação para outra.

Um caso pode ser a concatenação de strings: toma-se duas strings e acres-

centa-se (concatena-se) a segunda no final da primeira, algumas linguagens admi-

tem o uso do operador (+). Exemplo: strings "REFRIGERA" + "DOR" = "REFRIGE-

RADOR".

7.3 AVALIAÇÃO DE EXPRESSÕES

Expressões que apresentam apenas um único operador podem ser avaliadas

diretamente. No entanto, à medida que as mesmas vão-se tornando mais complexas

com o aparecimento de mais de um operando numa mesma expressão é necessária

a avaliação da mesma passo a passo, tomando um operador por vez. A sequência

de passos é definida de acordo com o formato geral da expressão, considerando-se

a prioridade (precedência) de avaliação de seus operadores e a existência ou não

de parênteses na mesma.

Regras essenciais:


_________________________________________________________________________________


1. Deve-se observar a prioridade dos operadores, conforme mostrado anteriormen-

te: operadores de maior prioridade devem ser avaliados primeiro. Se houver em-

pate com relação à precedência, então a avaliação se faz considerando-se a ex-

pressão da esquerda para direita.

2. Os parênteses usados em expressões têm o poder de "roubar" a prioridade dos

demais operadores, forçando a avaliação da subexpressão em seu interior.

3. Entre os quatro grupos de operadores existentes, a saber, aritmético, lógico, lite-

ral e relacional, há uma certa prioridade de avaliação: os aritméticos e literais

devem ser avaliados primeiro; a seguir, são avaliadas as subexpressões com

operadores relacionais e por último os operadores lógicos.

Exemplo: x = 2; y = 3,0.

(x * y + 1) + (x ^ y) / 2

(2 * 3 + 1) + (2 ^ 3) / 2

(6 + 1) + (8) / 2

7 + 4 = 11

7.4 PRIORIDADE (PRECEDÊNCIA) ENTRE TODOS OS OPERADORES

Operação Precedência

Parênteses mais internos 1

Operadores aritméticos 2

Operadores relacionais 3

Operadores lógicos 4

8 INSTRUÇÕES PRIMITIVAS

São comandos básicos que efetuam tarefas essenciais para a operação dos

computadores, como entrada e saída de dados e movimentação dos mesmos na

memória (comunicação com o usuário e com os dispositivos periféricos).

Todas as palavras que forem utilizadas como instruções primitivas (coman-

dos) são consideradas palavras reservadas e não poderão ser utilizadas como

nome de variável, o mesmo ocorre nas linguagens de programação.

Definição de termos essenciais:


_________________________________________________________________________________


• Dispositivo de entrada - é o meio pelo qual as informações (dados) são transfe-

ridas pelo usuário ou pelos níveis secundários de memória do computador.

Exemplos: teclado, discos magnéticos, modem, terminais de rede.

• Dispositivo de saída - é o meio pelo qual as informações (dados) são transferi-

das pelo computador ao usuário ou aos níveis secundários de memória. Exem-

plos: monitor de vídeo, impressora, discos magnéticos, modem.

• Sintaxe - é a forma como os comandos devem ser escritos a fim de que possam

ser entendidos pelo tradutor de programas. A violação das regras sintáticas é

considerada um erro sujeito à pena de não reconhecimento do comando por par-

te do tradutor (compilador).

• Semântica - é o significado, ou seja, o conjunto de ações que serão exercidas

pelo computador durante a execução do referido comando.

8.1 INSTRUÇÃO PRIMITIVA DE ATRIBUIÇÃO

É a principal maneira de se armazenar uma informação numa variável.

Em pseudocódigo sua sintaxe é:

<nome_da_variável> := <expressão>;

Em fluxograma:

Regras básicas:

• Deve haver compatibilidade entre o tipo de dado resultante da avaliação da ex-

pressão e o tipo de dado da variável.

• Coerção – é a exceção em relação a regra anterior, onde à uma variável do tipo

real pode ser atribuído o resultado de tipo inteiro da avaliação de uma expres-

são. Neste caso o resultado de tipo inteiro é convertido para o tipo real e poste-

riormente armazenado na variável.

<Variável> = <Expressão>


_________________________________________________________________________________


8.2 INSTRUÇÃO PRIMITIVA DE SAÍDA DE DADOS

Admite como argumentos uma lista de variáveis, um literal, ou uma mistura

de ambos. No primeiro caso o valor de cada uma das variáveis é buscado na memó-

ria e colocado no dispositivo de saída. No caso de literais estes são copiados dire-

tamente no dispositivo de saída. É o meio pelo qual as informações contidas na

memória do computador são colocadas nos dispositivos de saída, para que o usuá-

rio possa consultá-las.


Escreva <lista_de_variáveis>;

ou

Escreva <literal>;

Característica:

• Em uma mesma linha de instruções pode-se misturar nomes de variáveis com

literais na lista.

Exemplo: Considerando as variáveis:

x := 10; tipo := "inteiro";

Escreva "O valor de x é ", x ," esta variável é do tipo ", tipo;

Resulta em:

O valor de x é 10 esta variável é do tipo inteiro

8.3 INSTRUÇÃO PRIMITIVA DE ENTRADA DE DADOS

Busca no dispositivo de entrada, dados que são guardados nas posições de

memória correspondentes às variáveis da lista que lhe são passadas como argu-

mento. É a forma que um usuário pode fornecer informações ao computador .


Leia <lista_de_variáveis>;

• Uma preocupação constante de um bom programador deve ser a de conceber

um programa 'amigo do usuário'. Isto é traduzido no planejamento de uma inter-

face com o usuário (meio pelo qual um programa e o usuário 'conversam'). Isto

se resume em duas regras básicas.

1. Toda vez que um programa estiver esperando que o usuário forneça a ele um

determinado dado (operação de leitura), ele deve antes enviar uma mensagem


_________________________________________________________________________________


dizendo ao usuário o que ele deve digitar, por meio de uma instrução de saída

de dados;

2. Antes de enviar qualquer resultado ao usuário, um programa deve escrever uma

mensagem explicando o significado do mesmo.


_________________________________________________________________________________


9 TESTE DE MESA

• Após a elaboração de um algoritmo deve-se testá-lo realizando simulações com

o propósito de verificar se este está ou não correto.

• Teste de mesa é uma técnica que permite a simulação do processo de execução

de um algoritmo utilizando apenas papel e caneta/lápis.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

ALGORITMO Média_turma;

INICIO

VAR

REAL: N1, N2, N3, N4, soma, media;

LEIA n1, n2, n3, n4;

soma := (n1 + n2 + n3 + n4);

media := soma / 4;

SE media >= 7

ENTÃO

ESCREVA "Aprovado";

SENÃO

ESCREVA "Reprovado";

FIM_SE;

FIM.

Caso 1

linha n1 n2 n3 n4 soma media media>=7 saída

5 7 8 8 6

6 29

7 7.25

8 .V.

10 Aprovado

Caso 2

linha n1 n2 n3 n4 soma media media>=7 saída

5 5 3 6 7

6 21

7 5.25

8 .F.

12 Reprovado


_________________________________________________________________________________


10 ESTRUTURAS DE CONTROLE DO FLUXO DE EXECUÇÃO

São estruturas que permitem alterar a sequência de execução dos comandos

de um programa em função dos dados do mesmo.

Podem ser classificadas em:

• Estruturas sequenciais;

• Estruturas de decisão;

• Estruturas de repetição.

Um conceito passa a ser útil a partir deste momento: comando composto é

um conjunto de zero ou mais comandos (ou instruções) simples, como atribuições e

instruções primitivas de entrada ou saída de dados.

10.1 ESTRUTURA SEQUENCIAL

Os comandos de um algoritmo são executados numa sequência pré-

estabelecida. Cada comando é executado somente após o término do comando an-

terior.

Em termos de fluxograma, é caracterizado por um único fluxo de operações

(um único caminho orientado) no diagrama.

10.2 ESTRUTURAS DE DECISÃO

Neste tipo de estrutura o fluxo de instruções a ser seguido é escolhido em

função do resultado da avaliação de uma ou mais condições. Uma condição é uma

expressão lógica.

A classificação é feita de acordo com o número de condições que devem ser

testadas para que se decida qual caminho a ser seguido. Segundo esta classifica-

ção tem-se dois tipos de estruturas de decisão: Se , Escolha.

10.2.1 Estruturas de Decisão do tipo Se

Uma única condição (expressão lógica) é avaliada. Se o resultado desta ava-

liação for verdadeiro (.V.), então um determinado conjunto de instruções (comando

composto) é executado. Caso contrário, quando falso (.F.) um comando diferente é

executado, podendo ser um conjunto vazio.


_________________________________________________________________________________



Se <condição>

Então

<Comando_composto_1>;

Senão


Fim_se;

ou

Se <condição>

Então


Fim_se;

10.2.2 Estruturas de Decisão do tipo Escolha

Nesta estrutura pode haver uma ou mais condições a serem testadas e um

comando composto diferente associado a cada uma destas escolhas.


Escolha

Caso <Condição_1>


Caso <Condição_2>


.....

Caso <Condição_n>

<Comando_composto_n>;

Senão

<Comando_composto_s>;

Fim_escolha;


_________________________________________________________________________________


10.3 ESTRUTURAS DE REPETIÇÃO

São também chamadas de Laços ou Loops.

A classificação é feita de acordo com o conhecimento prévio do número de

vezes que o conjunto de comandos será executado, dividem-se em:

• Laços contados - quando se conhece previamente quantas vezes o co-

mando composto no interior da construção será executado;

• Laços condicionais - quando não se conhece de antemão o número de

vezes que o conjunto de comandos no interior do laço será repetido, pelo

fato de o mesmo estar amarrado a uma condição sujeita à modificação pe-

las instruções do interior do laço.

10.3.1 Laços Contados

É uma estrutura dotada de mecanismos para contar o número de vezes que o

corpo do laço (comando composto em seu interior) é executado.


Para <var> de <início> até <final> incr de <inc> faça

<Comando_composto>;

Fim_para;

Observações:

• <var> é uma variável que seu valor é alterado a cada iteração (volta do

laço).

• <início>, <fim> e <inc> podem ser constantes ou variáveis.

• <inc> é o valor que é adicionado à variável <var> a final de cada iteração

do laço. Há linguagens de programação que permitem que lhe seja atribu-

ído um valor negativo, de modo que o valor da variável <var> diminui a

cada iteração. Neste caso, deve-se atentar à necessidade de inversão do

sinal de comparação (de > para <) que é feito a cada volta do laço.

10.3.2 Laços Condicionados

São aqueles cujo conjunto de comandos em seu interior é executado até que

uma determinada condição seja satisfeita.

As construções mais comuns são: Enquanto e Repita.


_________________________________________________________________________________


10.3.2.1 Construção Enquanto


Enquanto <condição> faça

<comando_composto>;

Fim_enquanto;

10.3.2.2 Construção Repita


Repita

<comando_composto>;

Até_que <condição>;

• As construções Repita e Enquanto diferem uma da outra pelo fato de a primei-

ra (Repita) efetuar o teste de condição no final e portanto, o comando composto

é executado ao menos uma vez, no caso da Enquanto o teste da condição é fei-

to no início, desta forma o comando composto será executada zero ou mais ve-

zes.

10.4 ANINHAMENTOS

Um aninhamento ou embutimento é o fato de se ter qualquer um dos tipos

de construção apresentados anteriormente dentro do conjunto de comandos (co-

mando composto) de uma outra construção.


_________________________________________________________________________________


11 VARIÁVEIS INDEXADAS

Variável Indexada (Variáveis Compostas Homogêneas ou Agregados Homo-

gêneos) é um conjunto de variáveis do mesmo tipo, referenciáveis pelo mesmo no-

me e diferenciáveis entre si através de sua posição dentro do conjunto (índice).

Dimensão é o nome dado ao número de índices necessários a localização

de um componente (elemento) dentro da variável indexada e que corresponde tam-

bém ao número máximo de índices daquela variável indexada.

Quando uma variável indexada possui um único índice é chamada de vetor

(unidimensional) , quando possui dois ou mais índices é chamada de matriz (mul-

tidimensional - bidimensional, tridimensional...).

11.1 DECLARAÇÃO DE VARIÁVEIS INDEXADAS

Em pseudocódigo a sintaxe da declaração é a seguinte:

Var

<tipo_de_dado> : <nome_da_variável> [dim1] [dim2];

Onde:

• <tipo_de_dado> inteiro, real, literal ou lógico.

• <nome_da_variável> é o nome simbólico pelo qual o conjunto é identifi-

cado;

• dim1, dim2 são os valores máximos dos índices da variável em cada uma

das dimensões;

Exemplos:

Var inteiro : NÚMEROS[10];

real : SALARIOS[5];

literal : conjunto[100] de NOMES[30];/Pascal

ou

literal : NOMES[100][30] /C

real : MATRIZ [10] [15];

Pascal: NOMES : array [ 1 .. 99 ] of string[30];

C : char NOMES [100][30];


_________________________________________________________________________________


11.2 OPERAÇÕES BÁSICAS COM VARIÁVEIS INDEXADAS

O acesso individual a cada componente é realizado pela especificação de

sua posição por meio de seus índices.

Exemplos:

• NÚMEROS[3] - específica o terceiro elemento do conjunto NÚMEROS;

• SALÁRIOS[2] - específica o segundo elemento do conjunto SALÁRIOS;

• NOMES[7] - específica o sétimo elemento do conjunto NOMES;

• MATRIZ [5] [11] - específica o elemento da quinta linha e décima primeira

coluna do conjunto MATRIZ de números reais.

11.2.1 Atribuição

Em pseudocódigo a sintaxe do comando de atribuição é a mesma da instru-

ção primitiva de atribuição, sendo que o acesso a cada elemento deve ser individual

especificando seus índices.

<nome_da_variável> = <expressão>;

Exemplos:

NÚMEROS[3] = 10;

SALÁRIOS[2] = 500.00;

NOMES[20] = "PEDRO"; //os tratamentos de strings são diferentes entre C e Pascal

MATRIZ [5] [11] = -5.6;

11.2.2 Leitura

A leitura é feita passo a passo, um componente por vez, usando a mesma

sintaxe da instrução primitiva de entrada de dados (Leia <nome_da_variável>;) ex-

plicitando a posição (índice) do componente lido.

11.2.3 Escrita

A escrita também é feita passo a passo, um componente por vez, usando a

mesma sintaxe da instrução primitiva de saída de dados (Escreva <no-

me_da_variável>;) explicitando a posição (índice) do componente lido.


_________________________________________________________________________________


Exemplo: Algoritmo para leitura/escrita de um vetor.

Algoritmo leitura_de_vetor;

Inicio

Var

inteiro : NÚMEROS[10];

inteiro : I;

Para I de 1 até 10 faça

Leia NÚMEROS[I];

Fim_para;

Fim.

Exemplo de leitura com somador e como saída é escrito o total da soma:

Algoritmo leitura_e_soma_de_vetor;

Início

Var


real : SOMA;

inteiro : I;

SOMA = 0.0;


Leia NÚMEROS[I];

SOMA = SOMA + NÚMEROS[I];

Fim_para;

Escreva "Soma = " , SOMA;

Fim.

11.3 APLICAÇÃO DE CONJUNTOS EM ALGORITMOS

O universo de aplicação em algoritmos é bastante extenso. Neste capítulo

serão apresentadas duas aplicações importantes em processamento de dados:

pesquisa e classificação/ordenação.

• Pesquisa consiste na verificação da existência de um determinado valor

entre os componentes de um conjunto. Métodos mais difundidos: pesqui-

sa sequencial e pesquisa binária.

• Classificação/Ordenação consiste em arranjar os elementos de um con-


_________________________________________________________________________________


junto em uma determinada ordem, segundo um critério específico. Exem-

plos: ordem crescente ou decrescente de um conjunto de dados numéri-

cos, ordem alfabética de um conjunto de dados literais.

11.3.1 Método de Pesquisa Sequencial (ou Linear)

É o método mais simples e objetivo para se encontrar um elemento particular

num conjunto (em geral um vetor) não classificado (ordenado). Consiste na verifica-

ção de cada componente do conjunto sequencialmente (um após o outro) até que o

elemento desejado seja ou não encontrado.

Exemplo de algoritmo Pesquisa Sequencial - para ler um nome e verificar se o

mesmo se encontra num vetor de 100 nomes.


_________________________________________________________________________________


Algoritmo Pesquisa_sequencial;

Início

Var

literal : CHAVE[30];

literal : NOMES[100][30];

inteiro : I;

lógico : ACHOU;


Leia NOMES[I];

Se NOMES[I] = "" Então

Saia;

Fim_se;

Fim_para;

Leia CHAVE;

I = 1;

ACHOU = .F.;

Enquanto I <= 100 .E. ACHOU = .F. faça

Se NOMES[I] = CHAVE

Então

ACHOU = .V.;

Senão

I = I + 1;

Fim_se;

Fim_enquanto;

Se ACHOU = .V.

Então

Escreva "Nome: ",CHAVE," - encontrado";

Senão

Escreva "Nome: ",CHAVE," - NÃO encontrado";

Fim_se;

Fim.


_________________________________________________________________________________


11.3.2 Método de Pesquisa Binária

Neste método os elementos do vetor (lista) devem estar previamente classifi-

cados segundo algum critério (crescente, decrescente, alfabético).

Descrição narrativa do método:

• Obter um vetor classificado;

• Localizar o elemento que divide o vetor ao meio aproximadamente;

• Se o elemento que divide o vetor ao meio for o valor procurado a pesqui-

sa é dita bem-sucedida e é interrompida;

• Se o elemento procurado for menor que o elemento divisor, repetir o pro-

cesso na primeira metade e se for maior na segunda metade;

• O procedimento se repete até que se localize o valor procurado, ou até

que não haja nenhum trecho do vetor a ser pesquisado (pesquisa mal-

sucedida).


_________________________________________________________________________________


Exemplo de algoritmo Pesquisa Binária - para ler um nome e verificar se o mesmo

se encontra num vetor ordenado de 100 nomes.

Algoritmo Pesquisa_binária;

Início

Var

literal : NOMES[100][30];

literal : CHAVE[30];

inteiro : MÉDIO, ALTO, BAIXO, I;

lógico : ACHOU;

ALTO = 100;


Leia NOMES[I];

Se NOMES[I] = "" Então

ALTO = I – 1;

Saia;

Fim_se;

Fim_para;

Leia CHAVE;

ACHOU = .F.;

BAIXO = 1;

Enquanto BAIXO <= ALTO .E. .NÃO.ACHOU faça

MÉDIO = (BAIXO + ALTO) / 2;

Se CHAVE = NOMES[MÉDIO]

Então

ACHOU = .V.;

Senão

Se CHAVE < NOMES[MÉDIO]

Então

ALTO = MÉDIO - 1;

Senão

BAIXO = MÉDIO + 1;

Fim_se;


_________________________________________________________________________________


Fim_se;

Fim_enquanto;

Se ACHOU = .V.

Então

Escreva "Nome: ",CHAVE, " - encontrado";

Senão

Escreva "Nome: ",CHAVE, " NÃO encontrado";

Fim_se;

Fim.

Observações:

O método da pesquisa binária tem a desvantagem de exigir que o vetor seja

previamente ordenado o que não acontece com a pesquisa sequencial. Por outro

lado, o método da pesquisa binária em média é mais rápido que o da sequencial.

11.3.3 Método da Bolha de Classificação/Ordenação (Bubble Sort)

Este método não é o mais eficiente, mas é um dos mais populares devido à

sua simplicidade, corresponde ao método troca direta.

Descrição narrativa do método:

• Varrer o vetor comparando os elementos vizinhos entre si;

• Caso estejam fora de ordem, os mesmos trocam de posição entre si;

• Repetir os processos anteriores até o final do vetor;

• Na primeira varredura verifica se o ultimo elemento (maior de todos) do vetor

já esta no seu devido lugar, para o caso de ordenação crescente;

• A segunda varredura é análoga a primeira e vai até o penúltimo elemento;

• O processo é repetido até que seja feito um número de varreduras igual ao

número de elementos a serem ordenados menos um;

• Ao final do processo o vetor está classificado segundo o critério escolhido.


_________________________________________________________________________________


Exemplo de algoritmo Bubble Sort - para classificar um vetor de no máximo 50 ele-

mentos.

Algoritmo Bubble_Sort;

Início

Var


inteiro : I , J;

inteiro : AUX,ULTIMO;

ULTIMO = 50;


Leia NÚMEROS[I];

Se NÚMEROS[I] < 0 Então

ULTIMO = I - 1;

Saia;

Fim_se;

Fim_para;

J = ULTIMO;

Enquanto J > 1 faça

Para I de 1 até J-1 faça

Se NÚMEROS[I] > NÚMEROS[I + 1] Então

AUX = NÚMEROS[I];

NÚMEROS[I] = NÚMEROS[I + 1];

NÚMEROS[I + 1] = AUX;

Fim_se;

Fim_para;

J = J - 1;

Fim_enquanto;

Escreva "Vetor ordenado: ";

Para I de 1 até ULTIMO faça

Escreva NÚMEROS[I];

Fim_para;

Fim.


_________________________________________________________________________________


12 SUBALGORITMOS

É o nome dado a um trecho de um algoritmo mais complexo e que, em geral,

encerra em si próprio um pedaço da solução de um problema maior - o algoritmo a

que ele está subordinado.

Importância:

• Subdivisão de algoritmos complexos, facilitando o seu entendimento;

• Estruturação de algoritmos, facilitando principalmente a detecção de er-

ros e a documentação de sistemas;

• Modularização de sistemas, que facilita a manutenção de software e a

reutilização de subalgoritmos já implementados (biblioteca).

12.1 MECANISMOS E FUNCIONAMENTO

Um algoritmo completo é dividido num algoritmo principal e diversos subal-

goritmos (quantos forem necessários). O algoritmo principal é aquele por onde a

execução do algoritmo sempre se inicia.

O corpo do algoritmo principal normalmente é o primeiro trecho do pseudo-

código de um algoritmo. As declarações dos subalgoritmos devem estar logo no iní-

cio do algoritmo e as definições dos subalgoritmos devem estar logo após o corpo

do algoritmo principal, consequentemente após as declarações das variáveis glo-

bais (esta forma de representar subalgoritmos não é uma regra fixa).

Durante a execução do algoritmo principal, quando se encontra um comando

de chamada de um subalgoritmo, a execução do mesmo é interrompida. A seguir,

passa-se à execução dos comandos do corpo do subalgoritmo, ao seu término, re-

toma-se a execução do algoritmo que o chamou no ponto onde foi interrompida e

prossegue-se pela instrução imediatamente seguinte. Também é possível que um

subalgoritmo chame outro através do mesmo mecanismo.

Exemplo:

Algoritmo <nome_do_algoritmo>

Var <declaração_das_variáveis_globais>;

...

<declaração_dos_subalgoritmos>


_________________________________________________________________________________


...

Início

Var <declaração_das_variáveis_locais>;

<corpo_do_algoritmo_principal>;

Fim.

...

<definição_dos_subalgoritmos>

...

12.2 DECLARAÇÃO DE SUBALGORITMOS

Composta de:

• nome - nome simbólico pelo qual ele é chamado;

• tipo - é definido em função do tipo de valor que o subalgoritmo retorna

ao algoritmo que o chamou, podendo ser classificados em:

• funções - retornam um único valor ao algoritmo que o chamou;

• procedimentos - retornam nenhum ou mais valores ao algoritmo

chamador;

• parâmetros - são canais pelos quais dados são transferidos pelo algo-

ritmo chamador a um subalgoritmo, e vice-versa (bidirecional);

12.3 DEFINIÇÃO DE SUBALGORITMOS

Composta de:

• Cabeçalho, onde são definidos:

• nome - nome simbólico pelo qual ele é chamado;

• tipo - é definido em função do tipo de valor que o subalgoritmo retorna

ao algoritmo que o chamou, podendo ser classificados em:

• funções - retornam um único valor ao algoritmo que o chamou;

• procedimentos - retornam nenhum ou mais valores ao algoritmo

chamador;

• parâmetros - são canais pelos quais dados são transferidos pelo algo-

ritmo chamador a um subalgoritmo, e vice-versa (bidirecional);

• variáveis locais - são aquelas definidas dentro do próprio subalgorit-

mo e só podem ser utilizadas pelo mesmo.


_________________________________________________________________________________


• Corpo onde se encontram as instruções (comandos).

12.3.1 Funções

O conceito de Função é originário da ideia de função matemática (por exem-

plo: raiz quadrada, seno, coseno, tangente, logaritmo, etc...), onde um valor é calcu-

lado a partir de outro(s) fornecido(s) à função.

Sintaxe da definição de uma função:

Função <tipo_de_dado> : <nome> (parâmetros) :

Início

Var <lista_de_variáveis_locais>;

<comando_composto>;

Fim.

Exemplo de um algoritmo que emprega uma função para calcular o valor de

um número elevado ao quadrado.

Algoritmo função_elevado_quadrado

Função real : quadrado( real : W );

Algoritmo principal

Início

Var

real : X, Y ;

Escreva "Digite um número ";

Leia X;

Y = quadrado(X);

Escreva "O quadrado de X é ", Y;

Fim.

Função real : quadrado( real : W)

Início

Var

real : Z;

Z = W * W;

Retorne Z;

Fim.


_________________________________________________________________________________


12.3.2 Procedimentos

Um procedimento é um subalgoritmo que retorna zero (nenhum) ou mais va-

lores ao algoritmo chamador. Estes valores são sempre retornados por meio dos pa-

râmetros ou de variáveis globais, mas nunca explicitamente, como no caso das fun-

ções. Portanto, a chamada de um procedimento nunca surge no meio de expres-

sões, como no caso de funções.

Sintaxe da definição de um procedimento:

Procedimento <nome> (parâmetros)

Início

Var <lista_de_variáveis_locais>;

<comando_composto>;

Fim.

Exemplo de um algoritmo que emprega um procedimento para escrever o

valor das componentes de um vetor.

Algoritmo escreve_vetor

Var

inteiro : VET[10]; // variável global

Procedimento mostra();

Algoritmo principal

Início

.....

mostra();

.....

Fim.


_________________________________________________________________________________


Procedimento mostra()

Início

Var

inteiro : I;


Escreva VET[ I ];

Fim_para;

Fim.

12.4 VARIÁVEIS GLOBAIS E LOCAIS

Variáveis Globais são aquelas declaradas no início de um algoritmo. Estas

variáveis são visíveis (isto é, podem ser usadas) no algoritmo principal e por todos

os demais subalgoritmos.

Variáveis Locais são aquelas definidas dentro de um subalgoritmo e portanto

somente são visíveis (utilizáveis) dentro do mesmo. Outros subalgoritmos, ou mes-

mo o algoritmo principal, não podem utilizá-las. (mostra_var_global.cpp)

12.5 PARÂMETROS

São canais pelos quais se estabelece uma comunicação bidirecional entre

um subalgoritmo e o algoritmo chamador (algoritmo principal ou outro subalgoritmo).

Dados são passados pelo algoritmo chamador ao subalgoritmo, ou retornados por

este ao primeiro por meio de parâmetros.

Parâmetros Formais são os nome simbólicos introduzidos no cabeçalho de

subalgoritmos, usados na definição dos parâmetros do mesmo. Dentro de um su-

balgoritmo trabalha-se com estes nomes da mesma forma como se trabalha com va-

riáveis locais ou globais.

No exemplo abaixo X e Y são parâmetros formais da função Média:

Função real : Média ( X , Y : real)

Início

Retorne ( X + Y ) / 2;

Fim.


_________________________________________________________________________________


Parâmetros Reais são aqueles que substituem os parâmetros formais quan-

do da chamada de um subalgoritmo. Por exemplo, o trecho seguinte de um algorit-

mo invoca a função Média com os parâmetros reais 8 e 7 substituindo os parâme-

tros formais X e Y. Ex: Z = Média(8,7).

12.6 MECANISMOS DE PASSAGEM DE PARÂMETROS

A substituição dos parâmetros formais pelos reais durante a invocação de

um subalgoritmo é chamada de passagem de parâmetros e pode se dar segundo

dois mecanismos: passagem por valor (ou por cópia) ou passagem por referên-

cia.

12.6.1 Passagem de Parâmetros por Valor

O parâmetro real é calculado e uma cópia de seu valor é fornecida ao parâ-

metro formal, no ato da invocação do subalgoritmo. A execução do subalgoritmo

prossegue normalmente e todas as modificações feitas no parâmetro formal não

afetam o parâmetro real, pois trabalha-se apenas com uma cópia do mesmo.

Este tipo de ação é possível porque, neste mecanismo de passagem de pa-

râmetros, é feita uma reserva de espaço em memória para os parâmetros formais,

para que neles seja armazenada uma cópia dos parâmetros reais.

Exemplo:

Algoritmo pas_par_valor

Var inteiro : X;

Procedimento PROC( inteiro : Y )

Algoritmo Principal

Início

X = 1;

Escreva "Antes X = ", X;

PROC(X);

Escreva "Depois X = ", X;

Fim.


_________________________________________________________________________________


Procedimento PROC( inteiro : Y )

Início

Y = Y + 1;

Escreva "Durante X = ", X;

Fim.

Valores fornecidos pelo algoritmo: Antes X = 1

Durante X = 1

Depois X = 1

12.6.2 Passagem de Parâmetros por Referência

Neste mecanismo de passagem de parâmetros não é feita uma reserva de

espaço de memória para os parâmetros formais. Quando um subalgoritmo com pa-

râmetros passados por referência é chamado, o espaço de memória ocupado pelos

parâmetros reais é compartilhado pelos parâmetros formais correspondentes. As-

sim, as eventuais modificações feitas nos parâmetros formais também afetam os pa-

râmetros reais correspondentes.

Um mesmo subalgoritmo pode utilizar diferentes mecanismos de passagem

de parâmetros, para parâmetros distintos. Para diferenciar uns dos outros, conven-

cionou-se colocar o prefixo Var antes da definição dos parâmetros formais passados

por referência. Exemplo:

Procedimento PROC( inteiro : X , Y; Var real : Z; real : J )

Então:

• X e Y são parâmetros formais do tipo inteiro e são passados por valor;

• Z é um parâmetro formal do tipo real passado por referência;

• J é um parâmetro formal do tipo real passado por valor.

Exemplo do algoritmo do item anterior alterado para que o parâmetro Y do

procedimento seja passado por referência:

Algoritmo pas_par_referência

Var inteiro : X;

Procedimento PROC( Var inteiro : Y)


_________________________________________________________________________________


Algoritmo Principal

Início

X = 1;

Escreva "Antes X = ", X;

PROC(X);

Escreva "Depois X = ", X;

Fim.

Procedimento PROC( Var inteiro : Y)

Início

Y = Y + 1;

Escreva "Durante X = ", X;

Fim.

Valores fornecidos pelo algoritmo: Antes X = 1

Durante X = 2

Depois X = 2

13 RECURSIVIDADE

Um algoritmo cuja solução pode ser dividida em subproblemas mais simples,

e estas soluções requerem a aplicação dele mesmo é chamado recursivo.

Em termos de programação, uma rotina é recursiva quando ela chama a si

mesma, seja de forma direta ou indireta.

Em geral, uma rotina recursiva <R> pode ser expressa como uma composi-

ção formada por um conjunto de comandos <C> e uma chamada à rotina <R>.

Diz-se que uma rotina <R> é indiretamente recursiva se ela contém uma

chamada a outra rotina <S> que por sua vez contém uma chamada direta ou indire-

ta a <R>.

Nem sempre a recursão é explícita e às vezes, pode ser difícil percebê-la

através de uma simples leitura da rotina.

13.1 USO DE RECURSÃO NA SOLUÇÃO DE PROBLEMAS

Todo algoritmo deve ser finito. Para garantir que uma chamada recursiva não

criará um looping infinito, é necessário que ela esteja condicionada a uma expres-


_________________________________________________________________________________


são lógica que, em algum instante tornar-se-á falsa/e ou verdadeira (conforme o ca-

so) e permitirá que a recursão termine.

Na prática, ao definir uma função recursiva, dividimos o problema da seguinte

maneira:

• Solução trivial: dada por definição, não necessita de recursão para ser obtida.

Esta parte do problema é resolvida pelo conjunto de comandos da linguagem.

• Solução geral: parte do problema que em essência é igual ao problema original,

sendo, porém menor. A solução pode ser obtida por uma chamada recursiva.

Exemplo: fatorial;

Solução trivial : 0! = 1 implica na condição de parada da recursão!

Solução geral : n! = n*(n-1)!

A recursão é uma técnica que, por meio de substituições sucessivas, reduz o pro-

blema a ser resolvido a um caso de solução trivial.

Exemplo: Cálculo do Fatorial

Função Não Recursiva Função Recursiva

Função fat(n : inteiro): inteiro

Início

Var

I, fatorial = 1 : inteiro;

Para i de 1 até n incr 1 faça

fatorial = fatorial * i;

Fim_para;

Retorne(fatorial);

Fim.

Função fat(n : inteiro): inteiro

Início

Se n = 0 então

Retorne(1);

Senão

Retorne( n * fat(n-1) );

Fim_se;

Fim.


_________________________________________________________________________________


Teste de Mesa para versão recursiva: (para n = 4)

fat (n = 4)

= 24

fat (n = 3)

= 6

fat (n = 2)

= 2

fat (n = 1)

= 1

fat (n = 0)

= 1

Exercícios:

1) Construa uma função recursiva que calcule a soma dos números entre m e n.

Função soma_mn(inteiro: m, n): inteiro

Inicio

Se n = m

Então Retorne(m);

Senão Se m < n

Então Retorne(soma_mn(m, n-1) + n);

Senão Retorne(soma_mn(m, n+1) + n);

Fim_Se;

Fim_se;

Fim.


_________________________________________________________________________________


2) Faça uma função recursiva que calcule a série de Fibonacci, sendo:

n > 2 => Fn = Fn+1 + Fn+2

F0 = F1 = 1

F = 1, 1, 2, 3, 5...

Função Fibo(inteiro: n): inteiro

Início

Se n<2

Então Retorne(1);

Senão Retorne(Fibo(n-1) + Fibo (n-2));

Fim_se;

Fim.


_________________________________________________________________________________


13.2 QUANDO APLICAR RECURSÃO

Enquanto alguns problemas têm solução imediata com o uso de recursão, ou-

tros são praticamente impossíveis de se resolver de forma recursiva. É preciso ana-

lisar o problema e verificar se realmente vale a pena tentar encontrar uma solução

recursiva!

• Recursão bem utilizada: torna um algoritmo elegante, claro, conciso e simples;

• Solução não recursiva (iterativa): mais eficiente.

Cada chamada recursiva implica em um custo tanto de tempo quanto de es-

paço, pois cada vez que a rotina é chamada todas as variáveis locais são recriadas.

Decisão sobre uso da recursão: difícil! Necessário comparar as soluções, re-

cursiva e não recursiva.

Basicamente, qualquer tipo de recursão pode ser eliminado se utilizarmos no

seu lugar comandos de repetição e eventualmente, pilhas. Normalmente, as rotinas

assim modificadas são mais rápidas que suas correspondentes em versão recursi-

va. Entretanto, se o uso de muitos comandos de repetição e várias pilhas for neces-

sário para realizar a conversão da versão recursiva para a não recursiva talvez seja

melhor utilizar a recursiva.

14 PONTEIROS

Ponteiros proporcionam um modo de acesso às variáveis sem referenciá-las

diretamente. É uma representação simbólica de um endereço de memória.

14.1 CARACTERÍSTICAS NO USO DE PONTEIROS

• Possibilitam que funções possam modificar os argumentos que recebem (Passa-

gem de parâmetros por referência);

• Manipulam matrizes mais facilmente por meio de movimentação de ponteiros pa-

ra as mesmas;

• Possibilitam criar estruturas de dados mais complexas, como listas encadeadas

e árvores binárias, em que uma estrutura de dados deve conter referências so-

bre outra;

• Notação com ponteiros compilam mais rapidamente e tornam o programa mais


_________________________________________________________________________________


eficiente.

14.2 PONTEIROS EM LINGUAGEM C

14.2.1 Variáveis Ponteiro

Se uma variável vai armazenar um ponteiro, ela deve ser declarada como tal.

Uma declaração de ponteiro consiste em um tipo base, um * e o nome da variável.

Sintaxe: tipo *nome_da_variável;

14.2.2 Operadores unários de ponteiros

• & - retorna o endereço de memória da variável.

• * - retorna o conteúdo da variável localizada no endereço, ou seja, o conteúdo

da variável apontada.

• Na declaração * representa o tipo apontado, em outras instruções indica a variá-

vel apontada por.

• Ponteiros são sempre inicializados com o valor ZERO ou NULL.

14.2.3 Operações com ponteiros

14.2.3.1 Atribuição

Um endereço pode ser atribuído a um ponteiro. Exemplo: px = &x;

14.2.3.2 Acesso ao conteúdo

O operador unário trata seu operando como um endereço e acessa este en-

dereço para buscar o conteúdo do objeto alvo. Exemplo: y = *px;

14.2.3.3 Incremento de ponteiro

Incrementar um ponteiro acarreta movimentação do mesmo para o próximo

tipo apontado. Exemplo: px++; (se px é um ponteiro para int e tem o valor 3000,

após a execução do comando ele passa a ter o valor 3002).

*px = 0;

*px += 1;

(*px)++;

py = px;


_________________________________________________________________________________


14.2.3.4 Comparação entre ponteiros

É válido comparar duas variáveis do tipo ponteiro, que apontam para o mes-

mo tipo. Exemplos: if (px == py) | if (px != NULL)

14.2.3.5 Ponteiros e Arranjos (Matrizes/Vetores)

O compilador transforma matrizes em ponteiros quando compila, pois a arqui-

tetura do computador entende ponteiros e não matrizes. Dessa forma, qualquer ope-

ração com os índices de uma matriz pode ser feita com ponteiros.

O nome da matriz é um endereço, ou seja, um ponteiro (ponteiro constante).

Um ponteiro variável é um endereço onde é armazenado outro endereço.

Exemplo: main()

{

int num[] = {92, 81, 70, 69, 58}, d;

for(d = 0; d < 5; d++)

printf("%d\n", *(num+d));

getch();

}

*(matriz + índice) == matriz[índice]

Exemplo: endereço de num = 3000

&num[2] == (num+2) == 3004

num[2] == *(num+2) ==70

3000 [0] 92

3002 [1] 81

3004 [2] 70

3006 [3] 69

3008 [4] 58

Erro = *(num++) porque num é um ponteiro constante (mesmo que ocorre para

constantes).

String é um vetor de caracteres logo pode ser tratado com ponteiros também.

Exemplos: função strlen()


_________________________________________________________________________________


// Calcula tamanho de s

main()

{

char s[]="informática";

int n;

for(n = 0; s[n] != '\0'; n++);

printf("tamanho de s é %d",n);

getch();

}

// Calcula tamanho de s

main()

{

char *s = "informatica";

int i=0;

while(*s) {

i++;

s++;

}

printf("tamanho de s é %d",i);

getch();

}

Exemplos: função strcpy()

//Copia string t para s

main()

{

char s[]="informática";

char t[20];

int i = 0;

while((t[i] = s[i]) != '\0')

i++;

printf("%s",t);

getch();

}


_________________________________________________________________________________


15 VARIÁVEIS COMPOSTAS HETEROGÊNEAS (AGREG. HETEROGÊNEOS)

Em um conjunto homogêneo as variáveis são do mesmo tipo primitivo e em al-

guns casos não são suficientes para representar todas as informações. Às vezes, é

necessário criar novos tipos de dados.

A criação de novos tipos de dados permite representar melhor a informação que

está sendo tratada. Neste caso, é um conjunto em que os elementos não são ne-

cessariamente do mesmo tipo, ou seja, um conjunto composto de elementos hetero-

gêneos, mas que são logicamente relacionados. Exemplo: dados de funcionários de

uma empresa, dados dos alunos, dados de uma conta telefônica…

15.1 TIPOS DEFINIDOS PELO PROGRAMADOR

A criação deve ser antes da declaração das variáveis que utilizarão este tipo:

Tipo

nome do tipo = especificação do novo tipo;

Var

especificação do novo tipo : Lista de variáveis;

15.2 ESTRUTURAS REGISTROS

Principal estrutura para armazenar dados heterogêneos, corresponde a um

conjunto de informações logicamente relacionadas, porém de tipos diferentes.

Um registro é composto por campos que são partes que especificam cada

uma das informações.

Exemplo: passagem de ônibus:

Número: Gestante:

Origem: Destino:

Data: Horário:

Poltrona: Distância:


_________________________________________________________________________________


15.2.1 Declaração

Tipo IDENTIFICADOR = registro

tipo1 : campo1;

tipo1 : campo2;

…

tipon : campo n;

Fim_registro;

Var

IDENTIFICADOR : lista de variáveis;

Exemplo:

Tipo REGPASSAGEM = registro

inteiro : NUMERO;

lógico : GESTANTE;

caracter : ORIGEM[20], DESTINO[20];

caracter : DATA[08], HORARIO[6];

inteiro : POLTRONA;

real : DISTANCIA;

Fim_registro;

Var

REGPASSAGEM : Passagem;

15.2.2 Manipulação

Leia Passagem.NUMERO;

Escreva Passagem.DESTINO;

Passagem.DATA = "01032017";

15.3 REGISTRO DE CONJUNTOS

Os registros podem ser compostos de outros tipos de dados definidos pelo

programador.

Exemplo: Registro de estoque de um produto, contendo como um de seus campos

um valor numérico que indica as baixas por dia útil da semana.

Código Produto:

Nome do Produto:

Preço:

Baixa: | | | | |

1 | 2 | 3 | 4 | 5 | 6


_________________________________________________________________________________


Tipo vetor_dias = vetor [6] de inteiro;

Tipo REGPROD= registro

inteiro : CODIGO;

caracter : DESCRICAO [30];

real : PRECO;

vetor_dias : BAIXA;

Fim_registro;

Var

REGPROD : PRODUTO; /*variável do tipo definido */

15.3.1 Manipulação

Leia PRODUTO.DESCRICAO;

.......

Para i de 1 até 6 faça

Leia PRODUTO.BAIXA[I];

Fim_para;

Exemplo: Se quiser manter as baixas para todas as semanas de um mês:

Tipo MÊS_DIAS = matriz[4][6] de inteiro;

Tipo REGPROD2 = registro

caracter : DESCRICAO[30];

inteiro : CODIGO;

real : PRECO;

MÊS_DIAS : BAIXA;

Fim_registro;

Var

REGPROD2 : PRODUTO2;

• Para acessar quanto foi vendido do produto no terceiro dia da quarta semana:

PRODUTO2.BAIXA[4][3];

• Escrever o nome do produto, o código, o preço e as baixas da segunda semana:

Escreva PRODUTO2.DESCRIÇÃO;

Escreva PRODUTO2.CODIGO;

Escreva PRODUTO2.PREÇO;

Para i de 1até 6 faça

Escreva PRODUTO2.BAIXA[2][i];

Fim_para;


_________________________________________________________________________________


• Totalizar por dia da semana todos os dias do mês:

Para J de 1 até 6 faça

SOMA = 0;


SOMA = SOMA + PRODUTO2.BAIXA[I][J];

Fim_para;

Escreva "Dia – ",J, " totalizou ", SOMA, " baixas");

Fim_para;

Exemplo: Registro contendo um campo do tipo registro.

Nome:

Endereço

Rua N. CEP

Cidade: Estado

Salário:

Tipo ENDER = registro

caracter : RUA[30];

real : NUM, CEP;

caracter : CIDADE[20],ESTADO[2];

Fim_registro;

Tipo DADOS_FUNCIONARIOS = registro

caracter : NOME[30];

ender : ENDEREÇO;

real : SALARIO;

Fim_registro;

Var

DADOS_FUNCIONARIOS : Empregado;

Manipulação:

Empregado.NOME = "João da Silva";

Empregado.ENDERECO.RUA = "Rua Vicente Machado";

Empregado.ENDERECO.NUM = 100;

Empregado.ENDERECO.CEP = 84100970;

Empregado.ENDEREÇO.CIDADE = "Ponta Grossa";

Empregado.ENDEREÇO.ESTADO = "PR";

Empregado.SALARIO = 1500;

15.4 CONJUNTO DE REGISTROS

Quando é necessário armazenar um conjunto de registros.


_________________________________________________________________________________


Exemplo: Informações sobre todos os lugares de um ônibus

1 Número: Gestante:

2 Origem: Destino:

3 Data: Horário:

: Poltrona: Distância:

:

44

Tipo REGPASSAGEM = registro

inteiro : NUMERO;

lógico : GESTANTE;

caracter : ORIGEM[20], DESTINO[20];

caracter : DATA[08], HORARIO[6];

inteiro : POLTRONA;

real : DISTANCIA;

Fim_registro;

Tipo VETPASSAGEM = vetor[44] de REGPASSAGEM;

ou

Var

REGPASSAGEM : onibus[44];

• Para verificar quantos passageiros do ônibus são gestantes:

Para i de 1 até 44 faça

Se onibus[i]. GESTANTE = .V. então

num_gestantes = num_ gestantes + 1;

Fim_se;

Fim_para;

Exemplo: Vetor com 500 produtos

Tipo MÊS_DIAS = matriz[4][6] de inteiro;

Tipo REGPROD = registro

caracter : DESCRICAO[30];

inteiro : CODIGO;

real : PRECO;

MÊS_DIAS : BAIXA;

Fim_registro;


_________________________________________________________________________________


Var

REGPROD : PRODUTOS[500];

• Mostrar a baixa do décimo produto, do quarto dia da terceira semana:

Escreva PRODUTOS[10].BAIXA[3][4];

• Imprimir o total de movimentação do estoque para cada um dos 500 produtos:

Para N de 1 até 500 faça

SOMA = 0;


Para J de 1 até 6 faça

SOMA = SOMA + PRODUTO[N].BAIXA[I][J];

Fim_para;

Fim_para;

Escreva PRODUTO[N].DESCRIÇÃO, SOMA;

Fim_para;


_________________________________________________________________________________


16 ARQUIVOS

Um arquivo corresponde a um conjunto de informações (exemplo: uma estru-

tura de dados-registro), que pode ser armazenado em um dispositivo de memória

permanente, exemplo disco rígido. As operações básicas para manipulação de ar-

quivos são: abertura e fechamento do arquivo, leitura, gravação e exclusão de da-

dos (exemplo registros).

16.1 TIPOS DE ARQUIVOS

Os dados dos arquivos podem ser armazenados/acessados basicamente de

dois modos: sequencial ou direto (randômico).

16.1.1 Sequencial

Os dados são gravados no arquivo de forma contínua, um após o ou-

tro. A localização de qualquer um dos dados é indeterminada, para ter acesso a um

dado específico é necessário percorrer todos os que o antecedem e para gravar um

novo dado é necessário encontrar o final do arquivo.

16.1.2 Direto (Randômico)

Neste tipo de arquivo os dados (registros) são acessados de forma direta, ou

seja, através de algum de seus campos definido como chave, pode-se então aces-

sar os dados (demais campos do registro), sem a necessidade de processar os re-

gistros que estão fisicamente antes dele no arquivo.

16.1.2.1 Arquivo Indexado (Arquivo sequencial de acesso direto)

Normalmente é composto por mais de um arquivo: um arquivo de índices

(chaves) que contém a posição (endereço) de cada registro no outro arquivo de da-

dos.

16.2 TRATAMENTO DE ARQUIVOS EM LINGUAGEM C

16.3 COMANDOS EM PSEUDICÓDIGO PARA MANIPULAÇÃO DE ARQUIVOS

Abertura de arquivos

Sintaxe: ABRA(variável_arquivo);

Exemplo: ABRA(arq_alunos);


_________________________________________________________________________________


Fechamento de arquivos

Sintaxe: FECHA(variável_arquivo);

Exemplo: FECHA(arq_alunos);

Leitura (cópia para memória) de registro do arquivo:

Sintaxe: LEIA(variável_arquivo, variável_registro);

Exemplo: LEIA(arq_alunos, reg_aluno); // lê 1 registro

Gravação de registro do arquivo:

Sintaxe: GRAVA(variável_arquivo, variável_registro);

Exemplo: GRAVA(arq_alunos, reg_aluno); // grava 1 registro

Avançar ou retroceder posições (registros):

Sintaxe: AVANÇA(variável_arquivo, quantidade);

Exemplo: AVANÇA(arq_alunos, 1); // avança 1 registro a partir do atual

AVANÇA(arq_alunos, -1); // retrocede 1 registro a partir do atual

AVANÇA(arq_alunos, 10); // avança 10 registros a partir do atual

Posicionar em um registro específico:

Sintaxe: POSICIONE(variável_arquivo, posição);

Exemplo: POSICIONE(arq_alunos, 1); // posiciona no primeiro registro

POSICIONE(arq_alunos, 10); // posiciona no décimo registro

Função para detectar final de arquivo:

Sintaxe: FDA(variável_arquivo);

Exemplo: FDA(arq_alunos); // retorna .V. quando a posição atual for

// FIM DE ARQUIVO.


_________________________________________________________________________________


Exemplo de Pesquisa Sequencial em Arquivo:

LEIA nome;

ABRA(arq_alunos);

POSICIONE(arq_alunos, 1);

Achei = .F.

ENQUANTO .NÃO. FDA(arq_alunos) .E. .NÃO. achei FAÇA

LEIA(arq_alunos, reg_alunos);

SE nome = reg_aluno.nome

ENTÃO achei = .V.;

FIM_SE;

AVANÇA(reg_alunos, 1);

FIM_ENQUANTO;

SE achei = .V.

ENTÃO ESCREVA “achei o registro!”;

SENÃO ESCREVA “registro não encontrado!”;

FIM_SE;

FECHA(arq_alunos);


_________________________________________________________________________________


17 PROGRAMAÇÃO ORIENTADA A OBJETO

A programação orientada a objeto aproveitou as melhores ideias da progra-

mação estruturada e combinou-as como novos conceitos poderosos que levam a

ver na tarefa de programação uma nova luz. A tecnologia dos objetos permite que

um problema seja mais facilmente decomposto em subgrupos relacionados. Deste

modo, usando-se uma linguagem, pode-se traduzir esses subgrupos em unidades

autocontidas chamadas objetos. Todas as linguagens de programação orientadas a

objeto possuem três coisas em comum: objetos, polimorfismo e herança.

17.1 OBJETO

Objeto é um conceito que existe no mundo real, ou seja, objeto é tudo aquilo

com que podemos nos relacionar ou que se relacionam entre si. Por exemplo, clien-

te, fornecedor, pedido, empresa. O mundo real é repleto de objetos diferentes e com

diferentes formas de relacionamento. Então, podemos dizer que o mundo real é ori-

entado a objetos, e o fato de utilizar uma metodologia que se aproxime do mundo

real facilita muito a vida dos desenvolvedores. O desenvolvimento de software ori-

entado a objetos utiliza o mesmo conceito do mundo real para simular o que ocorre

no dia-a-dia quando um sistema está em execução.

Um objeto possui atributos (dados) e métodos (na programação estruturada cha-

mados procedimentos e funções) que atuam sobre ele.

Exemplo 1: Objeto Cachorro “Rex”

Atributos: nome, cor, peso, raça, tamanho da cauda;

Métodos: latir, cavar, dormir, comer;

Exemplo 2: Objeto funcionário “José”.

Atributos: nome, endereço, data de admissão, identidade, CPF;

Métodos: Consulta endereço, aumenta salário, paga comissão;


_________________________________________________________________________________


Exemplo 3: Objeto Matriz “A”

Atributos: linhas, colunas, elementos da matriz;

Métodos: inicialização, leitura, multiplicação por um valor (escalar), inversão, etc.

Exemplo 4: Considere o seguinte objeto de programação denominado Fatura. Nes-

te exemplo, uma fatura é um objeto tangível do mundo real; é o pedaço de papel

que diz o custo de um serviço ou produto vendido, que é enviado a um cliente.

Atributos: Valor Líquido, Imposto, Valor Total, Número do Cliente, Data

Métodos: Imprimir, Calcular Imposto, Marcar como Pago, Enviar.

Abstração: É a habilidade de ignorar os aspectos de um assunto não relevantes

para o propósito em questão, tornando possível uma concentração maior nos as-

suntos principais.

Análise de um Sistema Bancário

Objetos: Agência, Conta, Cliente, Banco.

Quais são os atributos de Agência?

Código?

Endereço?

A qual banco pertence?

Número de contas?

Data da última reforma, Área, Pé Direito?

Exercício 1: Em um torneio de Tênis, cada partida é jogada entre 2 jogadores. Pre-

tende-se manter informações sobre nome, idade dos jogadores, data da partida e

placar da mesma.

Exercício 2: Para um sistema de controle de um estacionamento, os seguintes re-

quisitos são definidos: (1) o controle é efetuado com base na placa do veículo; (2)

na entrada do estacionamento existirá um funcionário que introduz as placas dos


_________________________________________________________________________________


veículos no sistema, ficando de imediato registrado a data e a hora da entrada do

veículo no estacionamento. O sistema deve verificar se a placa do veículo está ca-

dastrada no sistema; (3) se a placa não estiver cadastrada, então deve-se criar um

novo veículo no sistema; (4) quando ocorrer a saída do veículo, um funcionário in-

troduz novamente a placa do veículo, sendo que o sistema calcula o custo do esta-

cionamento. Os veículos podem ser automóveis ou motos. O estacionamento pos-

sui um número de lugares limitados. Os lugares são caracterizados por um número,

piso e um estado (ex.: livre ou ocupado).

Exercício 3: A seguir, são listadas uma série de características (atributos e méto-

dos) de objetos: cor das penas, tocar, placa, velocidade do processador, cor, buzi-

nar, peso, tocar música, esquentar líquidos, capacidade de passageiros, número,

tamanho do monitor, capacidade em litros, acelerar, capacidade de memória princi-

pal, discar, formato do bico, preparar comida, piar, executar programas de edição de

texto, tipo de discagem, tipo de combustível, voar, acessar Internet, frear, voltagem.

Supondo os objetos Pássaro, Carro, Computador, Telefone e Forno Microondas,

descreva cada uma delas em termos de atributos e métodos.

17.1.1 Características fundamentais de um objeto:

Um objeto possui 3 características: atributos, comportamento e identidade.

• Atributos: Cada objeto pode possuir informações que são registradas na forma

de um conjunto de atributos (variáveis).

• Comportamento: Definido pelos métodos. O comportamento exige a escrita de

código em módulos (denominados MÉTODOS) que agem sobre os objetos. (Ca-

da objeto pode possuir um conjunto de habilidades de processamento que juntas

descrevem seu comportamento)

• Identidade: é a característica que diferencia um objeto de outro. O objeto deve

ter pelo menos uma propriedade que o identifique unicamente.

Como exemplo considere um objeto que represente uma disciplina de mate-

mática:


_________________________________________________________________________________


Identidade: poderia ser Lógica Computacional.

Atributos: poderiam ser Carga Horária, Pré-requisitos, Ementa, Alunos Matriculado

e Notas.

Comportamento: poderia incluir a capacidade de Calcular a Média da Turma, Ins-

crever um Novo Aluno e Registrar Notas dos Alunos.

17.1.2 Enfoque estruturado x Enfoque Orientado a Objetos:

• Estruturado: Ênfase nos procedimentos e funções (em POO chamados méto-

dos), implementados em blocos estruturados;

• Enfoque OO: atributos (dados) e métodos fazem parte de um só elemento bási-

co (objeto). Os elementos básicos comunicam-se entre si, caracterizando a exe-

cução do programa a dados e métodos ENCAPSULADOS em um só elemento.

17.2 CLASSES

Ao contrário dos objetos, que representam entidades individualizadas, as clas-

ses são representações genéricas. Elas são abstrações de um coletivo de entidades

do mundo real. Isto significa que elas representam um modelo comum para um con-

junto de entidades semelhantes. Imaginando, por exemplo, os alunos envolvidos em

um sistema acadêmico, cada aluno (Marcia, Vinicius, Cláudia, etc) é uma entidade

individualizada que poderia ser representada por um objeto. Observando-se estes

objetos e comparando-os, pode-se constatar que o conjunto de seus atributos (no-

me, sexo, idade) e seus comportamentos são análogos, embora obviamente os va-

lores dos atributos sejam diferentes.


_________________________________________________________________________________


A partir da observação de atributos e comportamento comum a um conjunto de

entidades similares, é possível estabelecer um modelo genérico para este coletivo

de entidades. Este modelo conteria os atributos e comportamentos comuns a este

coletivo. Desta forma, seria possível definir um modelo genérico para todos os alu-

nos no exemplo anterior. Este modelo genérico é, em conseqüência, uma abstração

dos alunos que denomina-se Classe na orientação a objetos.

A definição das classes de um sistema passa necessariamente pela observa-

ção do mundo real buscando-se determinar coletivos de entidades semelhantes que

possam ser abstraídas em uma representação genérica.

• Descrevem um conjunto de objetos semelhantes;

• Pode ser considerado como um "molde" para a criação de objetos;

Ex.: Os objetos Maria e João pertencem a classe Pessoa, pois todos tem um

nome, uma idade etc.

Um programa orientado a objetos pode ser formado por diversas classes, e

conseqüentemente por vários objetos.

Programa Controle_Acadêmico

Classe Disciplina

Classe Aluno Classe Professor

Objeto

Português

Objeto

Matemática

Objeto

Maria Objeto

José Objeto

Carlos Objeto

Cláudia


_________________________________________________________________________________


17.2.1 Declaração de Classes em Java

No geral, a declaração de classe em Java apresenta a seguinte forma:

modificador class nome_da_classe

A parte da declaração que está em itálico (class e nome_da_classe) são obri-

gatórios na criação de uma classe.

ex.:

public class Pessoa {...}

Modificador: os modificadores de uma declaração de classe determinam o modo

como uma classe pode ser utilizada (no momento não vamos detalhar este assunto

– utilizaremos sempre o modificador chamado public).

class: palavra reservada da linguagem Java e indica uma classe.

Nome da classe: as regras relacionadas aos nomes das classes são as mesmas de

qualquer outro identificador do Java. Deve começar com uma letra, não pode conter

espaços, etc.

Exemplo de uma classe completa:

public class Pessoa

{

//definição dos atributos da classe

String nome;

int idade;

String cpf;

//definição dos métodos da classe

public String obtem_nome()

{

return nome;

}

public void altera_nome(String novo_nome)

{

nome = novo_nome;

}

}


_________________________________________________________________________________


17.3 MÉTODOS

A grande maioria dos programas de computador que resolvem problemas do

mundo real são bastante complexos. A experiência mostrou que a melhor maneira

de desenvolver e manter um programa complexo (e extenso) é construí-lo a partir de

pedaços pequenos e simples (chamados módulos). Esta técnica é chamada dividir

para conquistar.

Em linguagens de programação orientadas a objetos os módulos são chamados

de métodos e classes. (Será abordado neste item somente a construção e utiliza-

ção de métodos).

A modularização de um programa vem a trazer uma série de vantagens:

• Torna o programa mais fácil de escrever. o desenvolvedor pode focalizar pe-

quenas partes de um problema complicado e escrever a solução para estas

partes, uma de cada vez, ao invés de tentar resolver o problema como um to-

do de uma sé vez.

• Torna o programa mais fácil de ler: o fato do algoritmo estar dividido em mó-

dulos permite que alguém, que não seja o seu autor, possa entender o pro-

grama mais rapidamente por tentar entender os seus módulos separadamen-

te, pois como cada módulo é menor e mais simples do que o programa “mo-

nolítico” correspondente ao programa modularizado, entender cada um deles

separadamente é menos complicado do que tentar entender o programa co-

mo um todo de uma só vez.

• Eleva o nível de abstração: é possível entender o que um programa faz por

saber apenas o que os seus módulos fazem, sem que haja a necessidade de

entender os detalhes internos aos módulos. Além disso, se os detalhes nos

interessam, sabemos exatamente onde examiná-los.

• Economia de tempo, espaço e esforço: freqüentemente, necessitamos execu-

tar uma mesma tarefa em vários lugares de um mesmo programa. Uma vez

que um módulo foi escrito, ele pode ser “chamado” quantas vezes quisermos

e de onde quisermos dentro do programa, evitando que escrevamos a mes-


_________________________________________________________________________________


ma tarefa mais de uma vez no programa, o que nos poupará tempo, espaço e

esforço.

• Estende a linguagem: uma vez que um módulo foi criado, podemos utilizá-lo

em outros programas.

17.3.1 Elementos de um método

Métodos1 possuem dois componentes: corpo e assinatura (também chamada

interface). O corpo de um método é o grupo de comandos que compõe o trecho de

código correspondente ao método. Já a assinatura de um método pode ser vista

como a descrição dos dados de entrada e de saída deste.

A assinatura de um método é definida em termos de seus parâmetros. Um pa-

râmetro é uma variável com o objetivo de se informar um valor para um método uti-

lizar.

Quando criamos um método, especificamos o número e tipos de parâmetros que

ele necessita. Isto determina a assinatura do método. Qualquer algoritmo que use

um método deve utilizar os parâmetros que são especificados na assinatura do mé-

todo para se comunicar com ele.

17.3.2 Descrição de um método

Um método pode:

• ter um valor de retorno: a execução do método tem como resultado o retor-

no de um valor ao programa que o chamou (na programação estruturada

chamamos de função). Ex.: método que calcular o seno de um número.

• não ter nenhum valor de retorno: a execução do método não retorna ne-

nhum valor ao programa que o chamou (na programação estruturada cha-

mamos de procedimento). Um método que não retorna valores pode ser utili-

1 Métodos definem o comportamento de um objeto. É através deles que objetos podem comunicar-se um com os

outros.


_________________________________________________________________________________


zado para a execução de diversas tarefas. Ex.: método que desenhe um cír-

culo na tela.

17.3.3 Declaração de métodos em Java

No geral, a declaração de métodos em Java apresenta a seguinte forma:

modificador valor_de_retorno nome_do_método (lista_de_parâmetros)

Ex.:

public double eleva_ao_quadrado(double numero)

A parte da declaração que está em itálico (valor de retorno, nome do método

e os parênteses) são obrigatórios na criação de um método.

Modificadores: permite que se definam propriedades do método (no momento não

vamos detalhar este assunto – utilizaremos sempre o especificador de acesso pu-

blic). Exemplos de modificadores: public, private, static, final, abstract, native, syn-

chronized.

Valor de Retorno: como descrevemos anteriormente, um método pode ou não re-

tornar um valor. Este valor de retorno pode ser um dos tipos primitivos de dados ( int,

long, boolean, double, etc.) ou pode ser um objeto qualquer. Quando queremos es-

crever métodos que não retornem nenhum valor, utilizamos em valor de retorno a

palavra reservada void.

Exemplo de método que retorna um valor inteiro:

public int obtem_idade() {...};

Exemplo de método que não retorna nenhum valor:

public void desenha(){...};


_________________________________________________________________________________


Nome do método: as regras relacionadas aos nomes dos métodos são as mesmas

de qualquer outro identificador do Java. Deve começar com uma letra, não pode

conter espaços, etc.

Lista de parâmetros: é a lista de informações que será passada para o método.

Ela apresenta a seguinte forma:

Tipo_de_dado nome_da_variável, Tipo_de_dado nome_da_variável, ...

Exemplo:

public double eleva_a_potencia(double base, double expoente){...};

A lista de parâmetros pode ser composta por quantos parâmetros você quiser. No

entanto, é importante observar que, se não houver parâmetros, exige-se que se dei-

xe os parênteses em branco.

Exemplo:

public void desenha(){...};

O corpo de um método é uma seqüência de comandos e, quando um método

tem um valor de retorno, este sempre deve ser finalizado com um comando especial

denominado comando de retorno. O comando de retorno em Java é descrito da se-

guinte forma:

return <valor de retorno>

Exemplo de método que calcula o quadrado de um número (possui um valor de re-

torno):

public double eleva_ao_quadrado(double numero)

{

double resultado;

resultado = numero * numero;


_________________________________________________________________________________


return resultado; //retorno do método

}

Exemplo de método que escreve algo na tela (não tem nenhum valor de retorno):

public void escreve(String valor)

{

System.out.println(“O resultado é: ”+valor);

}

Exercício: Complete a classe “Matematica” construindo os seguintes méto-

dos:

(a) calcular a raiz negativa da fórmula de Báskara;

(b) método que lê dois números (double) e retorna o menor deles;

(c) método que lê três números (double) e imprime na tela o maior e o menor valor;

(d) método para calcular e retornar o volume de um cilindro (V = *raio2*altura). De-

ve ser informado ao método o raio e a altura. Considere o valor de igual a

3.14159.

(e) método para calcular a distância entre dois pontos. Deve ser informado ao méto-

do as coordenadas destes pontos (ex. p1 = {x1,y1} e p2 = {x2,y2}). A fórmula pa-

ra este cálculo é: d = 2*((x2-x1)2 + (y2-y1)2)

Resposta:

public class Matematica

{

public double eleva_quadrado(double num)

{

double resultado;

resultado = num*num;

return resultado;

}

public double raiz(double num)

{

double resultado;

resultado = Math.sqrt(num);

return resultado;

}

public void escreve_cubo(double num)

{

double resultado = num*num*num;

System.out.println("O cubo do número "+num+" é "+resultado);


_________________________________________________________________________________


}

public double baskara_positiva(double a, double b, double c)

{

double dentroraiz, valor_raiz, resultado;

dentroraiz = eleva_quadrado(b) - (4*a*c);

valor_raiz = raiz(dentroraiz);

resultado = (-b + valor_raiz)/2*a;

return resultado;

}

public double baskara_negativa(double a, double b, double c)

{

double dentroraiz, valor_raiz, resultado;

dentroraiz = eleva_quadrado(b) - (4*a*c);

valor_raiz = raiz(dentroraiz);

resultado = (-b - valor_raiz)/2*a;

return resultado;

}

public double min2(double a, double b)

{

double menor;

menor = a;

if (a > b)

menor = b;

return menor;

}

public void min_max(double a, double b, double c)

{

double menor,maior;

// encontra maior

if ((a >= b) && (a >= c))

{

maior = a;

}

else

{

if (b >= c)

{

maior = b;

}

else

{

maior = c;

}

}

// encontra menor

if ((a <= b) && (a <= c))

{

menor = a;

}

else

{


_________________________________________________________________________________


if (b <= c)

{

menor = b;

}

else

{

menor = c;

}

}

System.out.println("Maior valor: "+maior+" Menor

valor:"+menor);

}

public double distancia_pontos(double x1, double y1, double x2,

double y2)

{

double xdif, ydif, xdifquad, ydifquad, dentroraiz, vraiz, d;

xdif = x2-x1;

ydif = y2-y1;

xdifquad = eleva_quadrado(xdif);

ydifquad = eleva_quadrado(ydif);

dentroraiz = xdifquad + ydifquad;

vraiz = raiz(dentroraiz);

d = 2*vraiz;

return d;

}

public double volume_cilindro(double raio, double altura)

{

double v,quad_raio;

quad_raio = eleva_quadrado(raio);

v = 3.14159*quad_raio*altura;

return v;

}

}

17.3.4 Escopo de Variáveis

O escopo de uma variável (atributo), é a parte do programa em que a variável

pode ser referenciada. Uma variável local declarada em um bloco de código (méto-

do) pode ser utilizada somente nesse bloco. Os escopos para um identificador (va-

riável) são o escopo de classe e escopo de bloco (na programação estruturada

chamados de escopo global e local).

Todos os atributos (variáveis) de uma classe podem encontrar-se definidas em

seu início (ou final), o que as torna passíveis de aplicação por qualquer módulo in-

tegrante. Estas variáveis têm escopo de classe.


_________________________________________________________________________________


Em alguns casos, uma determinada variável é utilizada apenas por um bloco de

código específico, o que não justifica uma definição da variável dentro do escopo de

classe. Quando a variável é declarada internamente a um bloco de código (método)

ela tem escopo de bloco.

Exemplo:

public class Escopo

{

int K,J;

public void m1()

{

int M;

}

public void m2()

{

int K,X,Y;

}

}

Observamos que as variáveis K e J definidas no início da classe são visíveis

a princípio a todo e qualquer método, ou seja, têm escopo de classe. A variável M é

local ao método m1 (bloco de código 1), ou seja, tem escopo de bloco. O mesmo

acontece com as variáveis X e Y do bloco de código 2 (escopo de bloco).

Em outra situação, temos um conflito com a variável K declarada no início da

classe (escopo de classe), e a variável K definida dentro do método m2 (escopo de

bloco). Neste caso, a variável a ser utilizada no interior do método m2 será a que foi

definida neste, ignorando a existência de outra variável de mesmo nome e de âmbi-

to global (com escopo de classe); temos então que os métodos m1 e m2 não enxer-

gam a mesma variável K: O método m1 vê a variável K de escopo de classe e o mé-

todo m2 enxerga apenas a variável K definida localmente a m2.

M

K,X,Y

J

K

1

2


_________________________________________________________________________________


Exercícios: para os seguinte programas, declare o escopo (de classe ou de bloco)

de cada uma das variáveis presentes.

(a) public class TesteCubo

{

int x;

public void escreve()

{

int r = 15;

for (x=1; x<=10; x++)

{

System.out.println(“Valor cubo: ”+cubo(x)+” Valor r: ”+r);

r = r + 15;

}

}

public int cubo(int y)

{

return y*y*y;

}

}

(b) public class Funcionário

{

int idade;

double salario_base;

long cpf;

String endereco;

public boolean validaCPF(long cpf)

{

boolean valido = false;

String Scpf = String.valueOf(cpf);

for (int i = 0; i < Scpf.length(); i++)

{

// (faz algo...)

}

return valido;

}

public double calcula_vencimento (int extras)

{

double salario=0.0;

if (validaCPF(cpf))

{

salário = salario_base+(extras*2.5);

// realiza outros calculos

}

return salario;

}

}


_________________________________________________________________________________


17.3.5 Criando Objetos

Quando definimos uma classe, esta, dentro do contexto da execução de um

programa que a utilize, não realiza nenhuma funcionalidade. Isto pode ser visto

através do exemplo a seguir: a classe Carro possui definido dentro dela um atributo

do tipo Motor (classe Motor) com o nome principal. Porém, até o momento não po-

demos utilizar o motor no carro, porque este não foi criado.

public class Motor

{

float potencia;

String marca;

boolean darpartida=false;

public void ligar()

{

darpartida = true;

}

public void desligar()

{

darpartida = false;

}

}

public class Carro

{

Motor motor_principal;

}

Para isso precisamos criar o objeto motor_principal (que é do tipo Motor) pa-

ra podermos utilizar em nosso problema.

Classe: Motor

Objeto: motor_trava_eletrica Objeto: motor_principal . . .

criar criar


_________________________________________________________________________________


O processo de criação de novos objetos é conhecido como criação de uma

instância ou instanciação de um objeto. Em Java, para realizarmos a criação de um

objeto (instanciação), utilizamos o operador new. A sintaxe de uma instrução envol-

vendo o operador new é a seguinte:

nome_da_instância_da_Classe = new nome_da_Classe(parâmetros_opcionais);

Para utilizarmos o motor_principal no Carro, iremos instanciá-lo:

public class Carro

{


public void inicializar()

{

motor_principal = new Motor();

}

}

A partir de agora podemos utilizar seus métodos e atributos: public class Carro

{



{


//atribuindo um valor a um atributo do objeto

motor_principal.potencia = 200.0;


motor_principal.marca = “Ford”;

//acessando um método do objeto

motor_principal.ligar();

}

}

Para acessarmos um atributo de um objeto utilizamos (desde que não possua

um modificador que restrinja seu acesso):

nome_objeto.nome_atributo;

Para acessarmos um método de um objeto utilizamos (desde que não possua

um modificador que restrinja seu acesso):

nome_objeto.nome_método(parâmetros_opcionais);


_________________________________________________________________________________


Exercício: defina classes que venham a compor uma Casa (incluir atributos e mé-

todos). Tal casa contém dois quartos, e em cada quarto existe uma cama, uma es-

crivaninha e uma cadeira. Um quarto possui duas portas, enquanto outro, somente

uma. A casa possui uma sala que possui um sofá e uma mesa de centro. Nesta sala

existem uma porta e duas janelas. O banheiro contém uma pia, um vaso sanitário e

um chuveiro. No banheiro existe uma janela e uma porta. A cozinha possui um fo-

gão, uma mesa, seis cadeiras, uma geladeira e um armário.

Com a definição das classes realizadas, relacione estas e crie as instâncias

de objetos necessárias para representar o enunciado.

17.3.6 Método Construtor

Quando um objeto é criado, ações podem ser executadas (inicialização de

atributos, etc) através de um método chamado construtor. Um construtor é um mé-

todo com o mesmo nome que a classe (incluindo distinção entre maiúsculas e mi-

núsculas). É invocado automaticamente toda vez que um objeto de uma classe é

instanciado (criado).

Ex.: para a classe Motor podemos criar um método construtor que realize a inicial i-

zação de seus atributos.

public class Motor

{

float potencia;

String marca;

boolean darpartida=false;

// método construtor

public Motor(float pot, String m)

{

potencia = pot;

marca = m;

}

public void ligar()

{

darpartida = true;

}

public void desligar()

{

darpartida = false;

}

}


_________________________________________________________________________________


Na classe Carro do exemplo anterior, criamos o objeto Motor e posteriormen-

te inicializamos seus atributos:

public class Carro

{



{



motor_principal.potencia = 200.0;


motor_principal.marca = “Ford”;

//acessando um método do objeto


}

}

Com a utilização da classe Motor, agora com o método construtor, podemos

inicializar tais atributos de uma forma direta:

public class Carro

{



{

//instanciando um objeto e chamando método construtor

motor_principal = new Motor(200.0,”Ford”);


}

}

Exercício: Para um sistema de uma biblioteca, temos as classes Biblioteca, Livro,

Aluno, Funcionário, Empréstimo. Defina essas classes, em termos de atributos e

métodos e crie objetos utilizando-se de métodos construtor.


_________________________________________________________________________________


17.4 HERANÇA

Uma das vantagens mais comentadas das linguagens orientadas a objetos é

o caráter reutilizável do código: você não tem que começar do nada cada vez que

escreve um programa. A herança é um recurso de linguagens orientadas a objetos

que ajuda a dar suporte à reutilização de código.

Herança é uma forma de reutilização de código em que novas classes são

criadas a partir de classes existentes, absorvendo seus atributos e comportamentos

e sofisticando-os com capacidades que as novas classes exigem.

Para entender melhor o significado do conceito de Herança, usaremos um

exemplo simples. Digamos que eu tenha uma classe Animal. Todos os objetos da

classe Animal possuem características (atributos) comuns, como peso, altura, idade,

estados como ter fome, etc. Também têm comportamentos (métodos) como Comer,

Procriar, Nascer, Morrer, se movimentar, etc. Podemos abstrair esse objeto Animal

para reduzi-lo à seguinte representação:

public class Animal

{

double peso, altura;

int idade;

boolean estaComFome;

public Animal()

{

peso=0.0;

altura=0.0;

idade=0;

estaComFome=false;

}

public void Comer()

{

if (estaComFome)

estaComFome = false;

}

}

Com a classe Animal criada posso usá-la em um aplicativo. Digamos que a

classe foi projetada e implementada de uma maneira ótima, que possui todos os

atributos e métodos necessários para a representação de um animal qualquer.


_________________________________________________________________________________


Imaginemos que eu tenha mais um aplicativo para fazer, e que este precise de

uma Classe Mamífero. A representação de um mamífero é muito parecida com a de

um Animal, mas ele possui atributos e métodos que não são comuns a todos os

animais: mamíferos (mamar, emitir sons etc.), além de fazerem algumas atividades

de forma diferente dos demais Animais (nem todos os animais comem ou procriam

como os mamíferos, por exemplo).

Numa linguagem de programação sem herança, a implementação da classe

Mamífero provavelmente implicaria na replicação do código de Animal, com as mo-

dificações necessárias para caracterizar a classe. Se fosse necessário implementar

uma classe Macaco, eu replicaria o código de Mamífero na nova classe. Uma classe

Chimpanzé teria o código de Macaco replicado em si, e assim sucessivamente.

Isso se tornaria um trabalho árduo e moroso. Se fosse necessário implementar

todas as classes existentes entre o Ser Vivo e o Mosquito, teríamos centenas de

classes, todas com replicação do código das classes anteriores. Além disso, se

houvesse a necessidade de modificar algum método de Animal que fosse comum a

todas estas centenas de classes, esta modificação teria que ser feita em todas elas,

uma a uma. Será que não existe uma maneira melhor?

Na verdade, é fácil perceber que Mamífero é na verdade uma especialização

de Animal, um herdeiro dessa classe. Assim, se eu dispuser de um mecanismo que

me permita declarar Mamífero como tal, e assim herdar todos os métodos e atribu-

tos da classe ancestral, não precisaremos replicar código, apenas incluiremos os

métodos e atributos específicos na classe Mamíferos, e redefiniremos os métodos

que acharmos necessários. O mecanismo que me permite isso é a Herança.

Dizemos que a classe Animal é uma superclasse e a classe Mamífero é uma

subclasse de Animal. Temos ainda que a classe Mamífero é uma especialização do

seu ancestral, que por conseqüência será uma generalização de seu sucessor. Com

isso formamos uma relação de hierarquia.


_________________________________________________________________________________


Para utilizarmos o conceito de herança em Java, usamos a palavra-chave ex-

tends. Voltando ao nosso exemplo, criaremos a subclasse Mamífero a qual herdará

todos os atributos e métodos contidos na superclasse Animal.

public class Mamifero extends Animal

{

boolean faseAmamentacao;

public Mamifero()

{

peso=0.0; //acesso a variável que está na superclasse

altura=0.0; //acesso a variável que está na superclasse

idade=0; //acesso a variável que está na superclasse

estaComFome=false; //acesso a variável da superclasse

faseAmamentacao =true;

}

public void Mamar()

{

if (faseAmamentacao)

Comer(); //chama método Comer da superclasse Animal

}

}

Exercício: utilizar herança para representar a seguinte hierarquia (definir atributos

e métodos):

Animal

Mamífero Ave Réptil

(superclasse)

(subclasses)

Animal

Mamífero

Ave

Réptil

Quadrúpede

Bípede

Rapina

Carnívoro

Elefante

Homem

Águia

Crocodilo


_________________________________________________________________________________


18 FASES DE DESENVOLVIMENTO DE UM PROGRAMA

O processo de desenvolvimento de um sistema computacional (programa,

software) visa responder as seguintes questões:

• Qual é o problema a ser resolvido?

• Quais as características do programa utilizado para resolver o problema?

• Como o programa será construído?

• Qual abordagem que será usada para descobrir erros cometidos no projeto e

construção do programa?

• Como o programa irá suportar a ação do tempo, quando correções, adaptações

e melhorias são requisitadas pelo usuário?

Análise Projeto

Fase de definição

Implementação Teste

Fase de desenvolvimento

Manutenção

Fase de manutenção

18.1 FASE DE DEFINIÇÃO (O QUE?)

Esta fase do desenvolvimento procura identificar:

• Requisitos do sistema;

• Informações a serem processadas;

• Funções, comportamento esperado e as interfaces;

• Restrições de projeto existentes.

Três tarefas ocorrem: análise do sistema, planejamento do projeto e análise de

requisitos.

18.2 FASE DE DESENVOLVIMENTO (COMO?)

Os seguintes tópicos são abordados:

• Definição das estruturas de dados e arquitetura do software;

• Definição das funções que serão implementadas;

• Caracterização das interfaces do sistema;

• Tradução do projeto em uma linguagem de programação;


_________________________________________________________________________________


• Como os testes serão realizados.

Três tarefas ocorrem: projeto do software, geração de código e teste de software.

18.2.1 Teste de Software

• Definição de teste e depuração;

• Teste é uma análise dinâmica do produto;

• Limitações da atividade de teste;

• Etapas da Atividade de Teste:

- planejamento;

- projeto de casos de teste;

- execução do programa com os casos de teste;

- análise dos resultados;

• Técnicas e Critérios de Teste de Software.

18.3 FASE DE MANUTENÇÃO (MUDANÇA)

Podem ser realizadas modificações no software para:

• Correção de erros;

• Adaptações;

• Evoluções;

• Prevenções.

Nessa fase são reaplicados os passos das fases de definição e desenvolvimento

no contexto de um programa já existente.

algoritmo e programaÇÃo-------------------------------------------------------...

Documents