Introduccion A Programacion Pt 701ni

Conceitos básicos de algoritmos e pseudocódigo ______________________________1 1.1 Algoritmo ______________________________________________________________ 1 1.2 O Pseudocódigo _________________________________________________________ 2 1.3 Variáveis _______________________________________________________________ 2 1.4 Literais ________________________________________________________________ 3 1.5 Expressões Aritméticas ___________________________________________________ 3 1.5.1 Operadores Aritméticos ________________________________________________________ 3 1.5.2 Regras de hierarquia dos operadores aritméticos _____________________________________ 4

1.6 Expressões Lógicas ou booleanas ___________________________________________ 5 1.7 Instruções Algorítmicas Básicas____________________________________________ 6 1.7.1 Entrada _____________________________________________________________________ 6 1.7.2 Saída _______________________________________________________________________ 6 1.7.3 Corpo do algoritmo____________________________________________________________ 6 1.7.3.1 Atribuição __________________________________________________ 6 1.7.3.2 Decisão Simples______________________________________________ 7 1.7.3.3 Decisão com caso oposto _______________________________________ 7 1.7.3.4 Iteração para frente ___________________________________________ 7 1.7.3.5 Iteração para trás _____________________________________________ 7 1.7.3.6 Loops ______________________________________________________ 8 1.7.3.7 Verificação de Casos __________________________________________ 8

Rotinas e agem de parâmetros_________________________________________9 Variáveis ________________________________________________________________________ 9 Parâmetros _______________________________________________________________________ 9 Parâmetros por valor _______________________________________________ 11 Parâmetros por referência ___________________________________________ 11

Exemplos de Invocações ____________________________________________________ 12 A Procedimentos _________________________________________________________________ 12 A Funções ______________________________________________________________________ 13

Conclusões _______________________________________________________________ 14

CONCEITOS BÁSICOS DE ALGORITMOS E PSEUDOCÓDIGO 1.1 Algoritmo Um algoritmo é um conjunto ordenado e finito de instruções que conduzem à solução de um problema. Na vida cotidiana executamos constantemente algoritmos. Por exemplo, ao instalar uma aparelho de som executamos as instruções contidas no manual do equipamento, este conjunto de instruções constituem um algoritmo. Outro caso de algoritmo é o algoritmo matemático de Euclides para a obtenção do máximo divisor comum de dois números. Quando um algoritmo pode ser executado por um computador, diz-se que é um algoritmo computacional, caso contrário, diz-se que é um algoritmo não computacional. Segundo isto, o algoritmo de Euclides é um algoritmo computacional, mas o algoritmo para instalar o aparelho de som é um algoritmo não computacional. Para um algoritmo poder ser executado por um computador, ele precisa ser expresso em instruções compreensíveis pelo computador, para isto é necessária uma determinada linguagem de programação. O algoritmo expresso em uma determinada linguagem de programação, denomina-se programa. Em outras palavras, podemos dizer que um programa é a implementação de um algoritmo em uma determinada linguagem de programação seguindo as regras estabelecidas pela linguagem escolhida. Na Figura a seguir, apresenta-se a relação entre problema, algoritmo e programa

Figura Problema, algoritmo e programa Todo algoritmo deve ter as seguintes características: Deve ser preciso, ou seja, cada instrução deve indicar em forma inequívoca o que deve ser feito. Deve ser finito, ou seja, deve ter um número limitado de os. Deve ser definido, ou seja, deve produzir os mesmos resultados para as mesmas condições de entrada. Todo algoritmo pode se decompor em três partes: 1. Entrada de dados. 2. Processo. 3. Saída de resultados

Exemplo: Algoritmo para preparar um molho de chocolate no microondas. ENTRADAS: 2 colheres de cacau 1/3 xícara de manteiga 2 colheres de água 1 xícara de açúcar ½ colherinha de baunilha 1 pitada de sal SAÍDAS: O molho de chocolate pronto para servir.. INÍCIO

FIM

Aquecer 1 minuto no microondas a água, com a manteiga e o cacau (tudo misturado). Acrescentar batendo os demais ingredientes. Colocar no microondas mais 30 segundos.

Evidentemente este é um algoritmo não computacional, não poderá ser executado por um computador, mas sim por uma pessoa.

Exemplo: Algoritmo para expressar em centímetros e polegadas uma quantidade dada em metros. ENTRADAS: A quantidade M de metros SAÍDAS: A quantidade C de centímetros e a quantidade P de polegadas INÍCIO Cálculo de centímetros : C = M*100 Cálculo de polegadas : P = C/2.54 FIM Este é um algoritmo computacional escrito em linguagem natural. Pode se fazer a conversão para um programa de computador (para o qual temos que escrevê-lo em uma linguagem de programação), mas também pode ser executado manualmente por uma pessoa.

1.2 O Pseudocódigo O pseudocódigo é uma linguagem de pseudoprogramação utilizada para escrever algoritmos computacionais. Como linguagem de pseudoprogramação, o pseudocódigo é uma imitação de uma ou mais linguagens de programação. Desta maneira podemos encontrar pseudocódigos orientados a linguagens de programação como Pascal, Java, C, C++, etc. No caso deste curso orientaremos os pseudocódigos à linguagem Java. O objetivo do pseudocódigo é permitir ao programador se focar nos aspectos lógicos da solução, evitando as regras de sintaxe das linguagens de programação. É também fácil modificar o pseudocódigo caso sejam encontrados erros ou anomalias na lógica do programa, além disso, é fácil sua tradução às linguagens de programação. Não sendo o pseudocódigo uma linguagem formal, os pseudocódigos variam de um programador para outro, ou seja, não há um pseudocódigo padrão.

1.3 Variáveis Uma variável é uma localização ou casa na memória principal que armazena um valor que pode mudar no decurso da execução do programa. Quando um programa precisa armazenar um dado, ele precisa de uma variável. Toda variável tem um nome, um tipo de dado e um valor. Antes de poder utilizar uma variável é necessário declará-la especificando seu nome e seu tipo de dado. Para declarar variáveis usaremos os seguintes formatos: Declaração de uma variável: tipo nome Declaração de várias variáveis com o mesmo tipo de dado: tipo nome1, nome2, nome3, ..., nomen Na qual tipo

nome1, nome2 nomen...,

É o tipo de dado da variável, que pode ser: INTEIRO (se a variável irá armazenar um número inteiro), REAL (se a variável irá armazenar um número decimal) , CARACTER (se a variável irá armazenar um caractere), CADEIA (se a variável irá armazenar um conjunto de caracteres) ou LOGICO (se a variável irá armazenar o valor verdadeiro ou o valor falso). Nomes das variáveis. O nome de uma variável deve começar com uma letra, um símbolo de sublinhado ou um símbolo de dólar. Outros caracteres do nome podem ser letras, símbolos de sublinhado ou símbolo de dólar. Também deve se levar em conta que uma letra maiúscula se considera diferente de uma letra minúscula.

Exemplo: Declaração de variáveis A seguinte instrução declara a variável idade de tipo INTEIRO e a variável desconto de tipo REAL. INTEIRO idade REAL desconto Isto cria as casas de memória idade e desconto. Depois da criação, as variáveis estão indefinidas ( ? ). idade desconto -

? ?

A seguinte instrução declara as variáveis nota1, nota2 e nota3, todas do tipo INTEIRO. INTEIRO nota1, nota2, nota3 Isto cria as casas de memória nota1, nota2 e nota3. Depois da criação, as variáveis estão indefinidas ( ? ). nota1 nota2 nota3

? ? ?

1.4 Literais Denominam-se literais todos aqueles valores que figuram no pseudocódigo e podem ser: Literais inteiros 12, 20300, 15, etc. Literais reais 3.1416, 2345.456, etc. Literais de caracteres 'a', 'B', ';', '<', '+', etc. Literales de cadeia "Oi", "Algoritmos Computacionais", etc. Literais lógicos verdadeiro, falso

1.5 Expressões Aritméticas Uma expressão aritmética é uma combinação de variáveis, literais e operadores aritméticos. .

1.5.1 Operadores Aritméticos Na tabela a seguir apresentam-se os operadores aritméticos que iremos utilizar. Tabela Operadores aritméticos Operador

Significado

Exemplo

+

Adição

a+b

-

Subtração

a-b

*

Multiplicação

a*b

/

Divisão

a/b

%

Resíduo

a%b

Os operadores aritméticos podem utilizar-se com tipos inteiros e reais. Se em uma operação com dois operandos, ambos os operandos são inteiros, o resultado é um inteiro; se algum deles é real, o resultado é real. Assim, 15/4 é 3 e não 3.75; no entanto, 15.0/4 é 3.75.

1.5.2 Regras de hierarquia dos operadores aritméticos Quando uma expressão aritmética tem mais de um operador aritmético, a ordem de aplicação dos operadores segue uma ordem precisa determinada pelas regras de hierarquia dos operadores aritméticos apresentados na seguinte tabela. Tabela Regras de hierarquia dos operadores aritméticos Operador

Ordem de avaliação

()

Avaliam-se em primeiro lugar

*, /, %

Avaliam-se em segundo lugar

+, -

Avaliam-se em terceiro lugar

Se existirem parênteses aninhados, avalia-se primeiro a expressão no par mais interno. Se vários operadores ou parênteses têm a mesma hierarquia, a avaliação será de esquerda para a direita. Exemplo: Qual é o equivalente em pseudocódigo da seguinte expressão algébrica?

a e= b c

Solução e = a/b/c Como todos os operadores têm a mesma hierarquia, a avaliação será de esquerda para a direita: Primeiro, será dividido a entre b. Segundo, o resultado já obtido de a/b será dividido entre c. Observe que a ordem desta execução de acordo com a expressão algébrica, por isso não é necessário nenhum par de parêntese.

Exemplo: Qual é o equivalente em pseudocódigo da seguinte expressão algébrica?

abc e= d e

Solução e = a*b*c/d/e Como todos os operadores têm a mesma hierarquia, a avaliação será de esquerda para a direita: Primeiro, será multiplicado a por b. Segundo, o resultado já obtido de a*b será multiplicado por c. Terceiro, o resultado já obtido de a*b*c será dividido entre d. Quarto, o resultado já obtido de a*b*c/d será dividido entre e. Observe que a ordem desta execução está de acordo com a expressão algébrica, por isso não é necessário nenhum par de parênteses.

1.6 Expressões Lógicas ou booleanas Uma expressão lógica combina variáveis, literais, operadores aritméticos, operadores relacionais e operadores lógicos. Os operadores relacionais e os operadores lógicos são exibidos nas tabelas que apresentamos a seguir. Ambos geram um resultado booleano. Tabela Operadores relacionais Operador

Significado

Exemplo

>

maior que

a>b

>=

maior ou igual a

a >= b

<

menor que

a

<=

menor ou igual a

a <= b

==

igual a

a == b

!=

diferente de

a != b

Tabela Operadores lógicos ou booleanos Operador

Significado

Exemplo

!

Não

!a

&&

E

a && b

||

Ou

a || b

Tabelas de verdade: a

!a

Verdadeiro

Falso

Falso

Verdadeiro

a

b

a && b

a || b

Falso

Falso

Falso

Falso

Falso

Verdadeiro

Falso

Verdadeiro

Verdadeiro

Falso

Falso

Verdadeiro

verdadeiro

Verdadeiro

Verdadeiro

Verdadeiro

1.7 Instruções Algorítmicas Básicas Existem três instruções algorítmicas básicas que são as seguintes.

1.7.1 Entrada Consiste em obter um dado de um dispositivo de entrada, como o teclado, e armazená-lo em uma variável. Em geral, a ação de ingressar um dado a uma variável é expressada no pseudocódigo mediante a palavra LER, da seguinte forma: LER variável Por exemplo, a instrução:

LER estatura solicita o ingresso de um valor de algum dispositivo de entrada (como o teclado), para guardar o valor digitado na variável estatura.

1.7.2 Saída Consiste em mostrar o valor de uma variável em um dispositivo de saída, como a tela. Em geral, a ação de mostrar o valor de uma variável é expressada no pseudocódigo mediante a palavra IMPRIMIR da seguinte forma: IMPRIMIR (variável) Por exemplo, a instrução:

IMPRIMIR (ImportânciaCompra) mostra, em algum dispositivo de saída (como a tela), o valor da variável ImportânciaCompra.

1.7.3 Corpo do algoritmo No corpo (ou body, em inglês) é onde escrevemos o que conforma o algoritmo como tal. Ou seja, é onde escrevemos, em forma ordenada, os os a seguir (as instruções) para resolver o problema que resolve o algoritmo. As instruções podem ser quaisquer das que se mencionam a seguir.

1.7.3.1 ATRIBUIÇÃO Consiste em atribuir a uma variável o valor de uma expressão. A expressão pode ser uma simples variável, um simples literal ou uma combinação de variáveis, literais e operadores. A atribuição é expressada no pseudocódigo da seguinte forma: variável = expressão No qual variável e o valor de expressão devem ter o mesmo tipo de dado. Quando se atribui um valor INTEIRO a uma variável REAL, então o valor INTEIRO será convertido em REAL antes de armazenar-se. Assim, ao atribuir o valor INTEIRO 25 a uma variável REAL, será armazenado 25.0. Exemplo: Algoritmo para expressar em centímetros e polegadas uma quantidade dada em metros. Sobre este mesmo exemplo já vimos antes seu “algoritmo computacional escrito em linguagem natural”. Vejamos agora uma solução “em pseudocódigo”, utilizando conceitos computacionais de variável, entrada de dados e saída de resultados. A solução considera que 1 metro = 100 centímetros e que 1 polegada = 2.54 centímetros. INÍCIO // Declara as variáveis M, C e P REAL M, C, P // Solicita o ingresso da quantidade em metros, guardando o mencionado valor na variável M

LER M // Calcula a quantidade em centímetros e o atribui à variável C C = M*100 // Calcula a quantidade em polegadas e o atribui à variável P P = C/2.54 // Mostra os valores das variáveis C e P IMPRIMIR (C, P) FIM

1.7.3.2 DECISÃO SIMPLES SE condição ......... FIM SE (IF cond – ENDIF)

1.7.3.3 DECISÃO COM CASO OPOSTO SE condição .......... SE NÃO ......... FIM SE (IF cond – ELSE – ENDIF)

1.7.3.4 ITERAÇÃO PARA FRENTE PARA valor inicial ATÉ valor final ................ FIM PARA (FOR … TO … [STEP] … ENDFOR)

1.7.3.5 ITERAÇÃO PARA TRÁS PARA valor inicial ATÉ valor final O -1 ................ FIM PARA

1.7.3.6 LOOPS

1.

Com verificação de condição ao início ENQUANTO condição FAZER .............. FIM ENQUANTO (DO WHILE cond)

2.

Com verificação de condição ao final REPETIR

.............. ATÉ condição

1.7.3.7 VERIFICAÇÃO DE CASOS EM CASO QUE variável SEJA CASO 1: ................. CASO 2: ................. CASO 3: ................. EM OUTRO CASO ................. FIM EM CASO (DO CASE CASE cond 1: ................. CASE cond 2: ................. OTHERWISE: ................. ENDCASE)

ROTINAS E AGEM DE PARÂMETROS

Uma rotina é um conjunto de sentenças que têm um identificador associado (nome da rotina) e são executadas como grupo quando invocada. Com as rotinas (também chamadas subprogramas) dispõe-se de uma estrutura muito apropriada para praticar o método de desenvolvimento em etapas sucessivas, que consiste em abordar o desenho dos programas decompondo o Problema em partes mais simples e repetindo este processo em forma sucessiva até que a solução de cada uma das partes seja trivial. Então resulta fácil desenvolver cada um dos elementos do programa, depurá-los e prová-los independentemente até ele funcionarem corretamente. Com esse enfoque, o programa fica organizado em módulos, que se expressam em forma de rotinas. O desenho modular está voltado a conseguir programas confiáveis e legíveis: - O esforço da programação concentra-se finalmente em subproblemas pequenos e simples. - É fácil escrever módulos pequenos livres de erro e verificá-los independentemente com dados simulados. - As listas pequenas som mais legíveis. - Resulta natural a adaptação ao trabalho em equipe. As tarefas de desenvolver os módulos podem se dividir entre várias pessoas. Geralmente, usam-se dois tipos de rotinas: os PROCEDIMENTOS e as FUNÇÕES. Os procedimentos são usados para realizar um conjunto de ações. Invocam-se com uma sentença executável denominada "chamada a procedimento". As funções são usadas para obter e devolver um valor. Invocam-se quando um identificador de função aparece dentro de uma expressão.

Variáveis Nas rotinas é possível utilizar e modificar variáveis do escopo de um programa em determinadas condições. -

-

As variáveis GLOBAIS são conhecidas ao longo de todo o programa e existem durante toda a execução. As variáveis que só têm significado em uma parte do programa chamam-se LOCAIS. São as que se declaram em um procedimento ou função e são conhecidas só no mesmo e em qualquer outro que estiver aninhado dentro. Têm a existência garantida só enquanto durar a execução do procedimento ou função na qual foram declaradas, depois, libera-se o espaço que ocupavam em memória ficando disponível para ser utilizado por outras. Em terceiro lugar, fala-se de variáveis DO SISTEMA, fazendo referência às que estão definidas na linguagem (compilador). Obviamente, estas são conhecidas em qualquer parte do programa.

Nestas condições, fica claro que em uma rotina (procedimento ou função) é possível manejar qualquer objeto global e todos os que tiverem sido declarados localmente. Embora seja possível, não convém atuar sobre variáveis globais do interior dos subprogramas para não correr o risco de modificar inadvertidamente valores externos ao procedimento ou função. É preferível trabalhar com variáveis de âmbito local e dispor de alguma via para relacioná-las com as definidas a nível global e com as que são locais de outras rotinas.

Parâmetros Em todos estes casos precisa-se dispor de algum mecanismo para intercambiar valores entre as rotinas e o resto do programa. Isso se obtém mediante as listas dos PARÂMETROS, chamados também ARGUMENTOS. Denominam-se parâmetros ou argumentos de uma rotina (procedimento ou função) aqueles dados (variáveis ou expressões) que são necessários para a execução da rotina. A rotina ou subprograma podem ser vistos como uma caixa preta que realiza uma função determinada,

para a qual precisa de certos dados de entrada para produzir certos dados de saída. Dados de entrada

Quando -

SUBPROGRAMA

Dados de saída

se desenha uma rotina, especifica-se: O QUE deve fazer a rotina Quais DADOS DE ENTRADA precisa Quais DADOS DE SAÍDA produz

Distingue-se então entre: Parâmetros de entrada: dados de entrada necessários para executar a rotina Parâmetros de saída: dados de saída que produz a rotina depois de sua execução Parâmetros de entrada/saída: dados que são usados como entrada e nos quais também é guardado um resultado de saída Na especificação da rotina descrevem-se os parâmetros formais. A esse respeito deve se dizer que: Os parâmetros especificam-se entre parênteses Os parâmetros separam-se com vírgula (',') A especificação dos parâmetros formais inclui: o Uma das palavras ENTRADA, SAÍDA, ENTRADA/SAÍDA, conforme for um dado de entrada, de saída ou de entrada/saída respectivamente o Ao igual que numa declaração de variáveis, inclui-se o tipo e o nome do parâmetro

Exemplo: desenhar um procedimento Adicionar que tome como entrada dois números inteiros e devolva como saída o resultado de sua adição. A seguir, especifica-se: O QUE deve fazer a rotina: adicionar dois números inteiros e devolver o resultado da soma. Quais DADOS DE ENTRADA precisa: adicionando1 e adicionando2 do tipo inteiro. Quais DADOS DE SAÍDA produz: resultado do tipo inteiro. ENTRADA inteiro somando1 inteiro somando2

Soma

SAÍDA inteiro resultado

A especificação do procedimento Adicionar é a seguinte: SUBPROGRAMA Somar (ENTRADA inteiro somando1, ENTRADA inteiro somando2, SAÍDA inteiro resultado) início fim

resultado = somando1 + somando2

Os parâmetros indicados na declaração das rotinas chamam-se PARÂMETROS FORMAIS. São identificadores de variáveis locais com as quais é possível introduzir e tirar valores nas rotinas. Nas funções, os parâmetros formais só permitem a entrada, visto que a saída produz um valor único que vai associado ao identificador da própria função. Os parâmetros indicados na chamada às rotinas são os PARÂMETROS REAIS. A correspondência entre os parâmetros formais e os reais se estabelece pela posição que ocupam nas listas, e a substituição se realiza aplicando alguns dos mecanismos seguintes: por VALOR, por

REFERÊNCIA. Segundo o mecanismo que atua, fala-se de várias classes de parâmetros:

PARÂMETROS POR VALOR Na substituição POR VALOR, avalia-se o parâmetro real, e o valor resultante dessa avaliação atribui-se ao parâmetro formal correspondente. O parâmetro real pode se expressar como uma constante, uma variável ou uma expressão. O uso de um parâmetro ado por valor consiste na mera transferência de um valor à rotina invocada (chamada). Estes são parâmetros de entrada. podem-se modificar dentro da rotina, mas isso não afeta o parâmetro real correspondente. Não permitem tirar informação da rotina.

PARÂMETROS POR REFERÊNCIA Permitem aplicar o mecanismo de substituição POR REFERÊNCIA, pelo que se produz uma associação entre parâmetro real e parâmetro formal que consiste em uma espécie de substituição. Na realidade atribuem-se ao identificador de parâmetro formal os mesmos endereços de memória que correspondem ao parâmetro real, de forma tal que qualquer modificação que se produzir dentro da rotina afeta os parâmetros reais que são entidades externas ao mesmo. Para descrever graficamente a situação, pode se imaginar uma flecha para cada parâmetro formal, que una seu nome com o endereço de memória no qual está armazenado seu parâmetro real correspondente. Toda operação que afetar o parâmetro formal na realidade é realizada sobre o parâmetro real. Com este mecanismo de substituição por referência, pode-se conseguir a transferência de informação com as rotinas nos dois sentidos: entrada e saída.

Exemplos de Invocações Conforme o que foi visto até agora, veremos exemplos de invocações (chamadas) a procedimentos e funções.

A Procedimentos O subprograma invocador, pode invocar o procedimento Somar, com diferentes valores de parâmetros conforme seja necessário. SUBPROGRAMA invocador inteiro V1, V2, V3; caractere c; início /*não é necessário inicializar V1 pois é ado como parâmetro de saída (parâmetro de retorno) */ invocar Somar (1, 2, V1); /* V1 tem o valor 3 depois da execução de Somar */ invocar Somar (V1,1+2, V2); /* V2 tem o valor 6 depois da execução de Somar e V1 não muda seu valor por ser parâmetro de entrada */ /* inicializa-se V3 pois é ado como parâmetro de entrada, deve então ir com algum valor */ V3 := 10; /* isto se lê assim: a V3 é atribuído o valor 10 */ invocar Somar (V2,V3, V2); /* uma mesma variável é ada como primeiro parâmetro e terceiro parâmetro; V2 vai com valor 6, e tem o valor 16 depois da execução de Somar. V3 não muda seu valor por ser parâmetro de entrada */ /* neste ponto cumpre-se que V1=3, V2=16 e V3=10*/ invocar Somar (1,3,5); invocar Somar (1,3,c); fim invocador;

/* ERRO, não é possível ar um valor como parâmetro de saída */ /* ERRO, não há compatibilidade de tipos no terceiro parâmetro */

A invocação de um subprograma é realizada com parâmetros reais. A esse respeito, é necessário dizer que:

•

Associa-se conforme a ordem de aparição, cada parâmetro formal com cada parâmetro real. Por exemplo, em invocar Somar(V1, 3, V2) associa-se: - o parâmetro real V1 com o parâmetro formal somando1; - o parâmetro real 3 com o parâmetro formal somando2; - o parâmetro real V2 com o parâmetro formal resultado;

•

Cada invocação é independente das demais, ou seja, com cada invocação existe uma nova associação entre parâmetros reais e formais, e portanto não é lembrado nada de possíveis invocações anteriores.

•

Deve haver coincidência ou compatibilidade de tipos entre os parâmetros formais e os parâmetros reais. Por exemplo, invocar Somar(1, 3, c) dá ERRO devido a que o parâmetro real c é de tipo caractere e o parâmetro formal resultado é de tipo inteiro.

•

O parâmetro real que se associa com um parâmetro formal de ENTRADA pode ser tanto uma variável como uma expressão. Por exemplo, em invocar Somar (V1,1+2, V2); - o parâmetro real V1 é uma variável, cujo valor se associa com o parâmetro formal somando1 - o parâmetro real 1+2 é uma expressão, cujo valor se associa com o parâmetro formal somando2

•

O parâmetro real que se associa com um parâmetro formal de SAÍDA deve ser uma variável, na qual se guarda o resultado devolvido pela rotina que se invocou. Por exemplo, em

invocar Somar(V2, V3, V2); - o parâmetro real V2 é uma variável que se associa (no terceiro parâmetro) com o parâmetro formal de nome resultado; mas em invocar Somar(1,3,5) - é um ERRO tentar associar um valor a um parâmetro formal de saída.

A Funções Existe um caso especial de procedimento, que retorna apenas um dado de saída. Neste caso, em lugar de definir um subprograma da seguinte forma SUBPROGRAMA nome_subprograma (ENTRADA…., SAÍDA tipo_saída nome_saída) sendo que possui um único parâmetro de saída, pode-se definir como uma função que devolve um valor do tipo tipo_saída tipo_saída FUNÇÃO nome_função (ENTRADA ...)

Por exemplo, em lugar de definir um procedimento Somar que receba dois parâmetros de entrada (somando1 e somando2), e devolva o resultado no parâmetro de saída (resultado) SUBPROGRAMA Somar (ENTRADA inteiro somando1, ENTRADA inteiro somando2, SAÍDA inteiro resultado) pode-se definir a função Somar, que receba os mesmos parâmetros de entrada que o procedimento, mas

•

na especificação de uma função deve-se indicar o tipo de dado de saída que devolve a função: inteiro FUNÇÃO Somar (ENTRADA inteiro somando1, ENTRADA inteiro somando2)

A implementação da função Somar é levemente diferente ao procedimento, dado que

• inteiro início

todas as funções devem devolver um valor do tipo que especificam em sua definição. FUNÇÃO

Somar

(ENTRADA

inteiro

somando1,

ENTRADA

inteiro

somando2)

devolver (somando1 + somando2); fim Somar; A diferença do procedimento Somar, na função não existe o parâmetro de saída resultado. Vejamos então como fica agora o invocador à função Somar: SUBPROGRAMA invocador inteiro V1, V2, V3; caráter c; início

/* atribui a V1 o resultado da função Somar */ V1 := invocar Somar (1, 2); /* V1 tem o valor 3 logo depois da execução de Somar */ /* atribui A V2 o resultado da função Somar */ V2 := invocar Somar (V1,1+2); /* V2 tem o valor 6 depois da execução de Somar e V1 não muda seu valor por ser parâmetro de entrada */ /* inicializa-se V3 pois é ado como parâmetro de entrada */ V3 := 10; /* atribui a V2 o resultado da função Somar */ V2 := invocar Somar (V2,V3); /* uma mesma variável é ada como primeiro parâmetro e usada para guardar o valor devolvido pela função; V2 tem o valor 16 depois da execução de Somar e V3 não muda seu valor

por ser parâmetro de entrada */ /* neste ponto cumpre-se que V1=3, V2=16 e V3=10 */ 5 := invocar Somar (1,3); c := invocar Somar (1,3); variável c */

/* ERRO, não é possível atribuir nada a um valor */ /*ERRO, não há compatibilidade de tipos entre a função Somar e a

fim invocador;

A invocação a uma função é também levemente diferente da invocação de um procedimento. A esse respeito é necessário dizer que:

•

Visto que as funções podem se considerar em si próprías como o valor de saída que devolvem, podem fazer parte de uma expressão. Ou seja, a invocação pode se usar em uma expressão da parte direita de uma atribuição, ou em uma expressão que faz parte de uma condição. Por exemplo, V1 := invocar Somar (1, 2); V2 := invocar Somar (V1,1+2); atribui-se às variáveis V1 e V2 o resultado de diferentes invocações da função Somar. Neste exemplo, pode-se encontrar uma única instrução equivalente a ambas as instruções: V2 := invocar Somar (invocar Somar (1, 2), 1+2); Em primeiro lugar, avalia-se a invocação mais interna Somar (1,2). O resultado é 3 e toma-se como primeiro parâmetro real da invocação mais externa. Avalia-se a expressão do segundo parâmetro real 1+2, e a seguir realiza-se a invocação mais externa Somar (3, 3). Por último, o resultado 6 é atribuido à variável V2.

•

Da mesma forma em que na associação de parâmetros reais e formais deve haver compatibilidade de tipos, também deve havê-la entre o tipo que devolve a função e a expressão em que é usada. Por exemplo, c := invocar Somar (1,3); dá ERRO devido a que não há compatibilidade de tipos entre a função Somar e a variável C.

Conclusões O uso de rotinas em um programa permite dividir um problema em vários problemas menores e portanto mais fáceis de solucionar. A modularização que se obtém, permite uma manutenção mais simples e oferece a possibilidade de reutilizar o código de um módulo (rotina) em outros programas. Para a agem de informação entre rotinas, utilizam-se parâmetros, também chamados argumentos. Os parâmetros podem ser: de entrada, de saída ou de entrada/saída. Isto determina se os parâmetros serão ados: por valor (parâmetros de entrada), o que implica que a rotina chamada não muda o valor que esse parâmetro tinha na rotina chamadora; ou se se serão ados por referência (parâmetros de entrada/saída), mediante o qual a rotina chamada pode mudar o valor original e a rotina chamadora recebe o novo valor. A agem de parâmetros é fundamental para garantir um correto fluxo de informação entre os distintos módulos de um programa, evitando atuar sobre variáveis globais do interior das rotinas para não correr o risco de modificar sem perceber valores externos a elas.