Escola Secundária/3 de Pinhal do Rei (402503)

Programação de Sistemas Informáticos

Módulo 3: Estruturas de controlo

Apresentação

Neste módulo serão abordadas as diferentes estruturas de controlo existentes numa

linguagem de programação, desde as estruturas de decisão até às estruturas de repetição, e a sua utilização no mundo da programação. Com base nestas estruturas, serão desenvolvidos programas já com uma maior complexidade.

Objectivos de aprendizagem

Utilizar e identificar instruções compostas. Identificar e utilizar estruturas de repetição num programa. Utilizar as várias estruturas de selecção. Desenvolver programas que utilizem combinações entre estruturas de repetição e de selecção. Criar menus de opções.

Conteúdos programáticos

Instruções compostas Estruturas de decisão

Estruturas de repetição

1. Instruções compostas

Página 1

Só em programas muito, muito simples é que se empregam exclusivamente instruções básicas ou simples. No entanto, a esmagadora maioria dos problemas que se tentam resolver através

da programação exige outros tipos de instruções, um pouco mais complexas, e que permitam

fazer programas com outras potencialidades.

Essas instruções mais complexas são as chamadas instruções compostas ou estruturadas ou ainda estruturas de controlo. São assim chamadas porque, por um lado, são instruções

que irão conter outras instruções, e, por outro, são instruções que nos permitem controlar

o fluxo das acções de um programa como, por exemplo, decidir que acção ou acções executar

de entre duas ou mais alternativas (estruturas de decisão ou de selecção), ou executar

repetidamente uma acção

ou um conjunto de acções (estruturas de repetição ou ciclos).

As principais estruturas de controlo usadas em programação classificam-se em:

° estruturas de decisão ou selecção:

o Com base numa condição (IF … THEN …[ELSE]);

o Com base numa variável de controlo ou selector (CASE … OF…);

° estruturas de repetição ou ciclos:

o Com base numa condição:

° no início do ciclo (WHILE …DO…);

° no final do ciclo (REPEAT …UNTIL…);

o Com base num contador (FOR …TO/DOWNTO…DO…).

2. Estruturas de Decisão

Como sabemos, um algoritmo é um conjunto de instruções que, executado numa determinada

sequência predefinida, nos conduz à resolução de um problema. Essa sequência de instruções diz-se

simples quando a ordem de execução das instruções é aquela em que as instruções aparecem

escritas no código-fonte do programa. Por exemplo:

Instrução 1: Escrever (“Cálculo da área de um rectângulo”)

Instrução 2: Ler (base)

Instrução 3: Ler (altura)

Instrução 4: area „ base * altura

Instrução 5: Escrever(“A área do rectângulo é: “, area)

Página 2

No entanto, existem muitas situações em que a complexidade dos problemas obriga a alterar a ordem de execução das instruções de um programa. Nesses casos utilizam-se instruções

estruturadas ou de controlo como é o caso das instruções estruturadas de decisão e de

repetição.

As estruturas de decisão permitem ao programa decidir qual o rumo de acção a tomar

mediante determinadas circunstâncias que se verifiquem durante a execução do mesmo. Por

exemplo, decidir se deve ou não efectuar determinada instrução ou decidir qual o conjunto de

instruções a executar perante várias alternativas possíveis.

Na generalidade das linguagens de programação encontramos dois tipos de estruturas de

decisão: a estrutura de decisão condicional e a estrutura de escolha múltipla. 2.1. Estrutura de decisão condicional simples

A estrutura de decisão condicional simples consiste apenas em decidir, com base numa

condição booleana, se determinada instrução (ou conjunto de instruções) será executada ou não.

Esta estrutura representa-se em Pascal por IF… THEN… e tem o seguinte diagrama

sintáctico:

IF Condição THEN Bloco de instruções ; em que bloco de instruções obedece ao seguinte diagrama:

instrução

BEGIN instrução ; END

Nesta estrutura, o programa só executará o bloco de instruções que se segue à palavra reservada THEN se a condição em causa for verdadeira (TRUE). Quer isto dizer que em função do

valor da condição, o programa decide se executa ou não o bloco de instruções associado a esta

estrutura.

A condição é qualquer coisa que devolva um valor booleano, ou seja, verdadeiro ou falso.

Quer isto dizer que pode ser uma expressão lógica ou relacional, uma função booleana ou apenas

uma variável booleana.

Exemplos:

1) IF (x > 7) THEN writeln (x,‘ é maior que 7’);

2) IF (odd(y))THEN writeln (y,’ é ímpar’);

3) IF (x > 7 AND odd(y)) THEN BEGIN

writeln(x,‘ é maior que 7’); writeln (y,’ é ímpar’);

END;

4) IF (aux) THEN writeln (‘A variável aux tem valor TRUE’); 2.2. Estrutura de decisão condicional composta

Página 3

A estrutura de decisão condicional composta consiste numa extensão da estrutura anterior no

sentido em que, com base numa condição booleana, permite ao programa optar por uma de duas

sequências de acção diferentes. Assim, se a condição for verdadeira executa uma instrução ou

conjunto de instruções, mas se a condição for falsa executa outra instrução ou outro conjunto de

instruções. Deste modo, ao contrário do que acontece com a decisão condicional simples, a estrutura

de decisão condicional composta executará sempre alguma coisa.

Esta estrutura representa-se em Pascal por IF… THEN… ELSE e tem o seguinte diagrama

sintáctico:

IF Condição THEN Bloco de instruções 1

; Bloco de instruções 2 ELSE

Neste caso temos que o bloco de instruções 1 será executado apenas quando a condição for verdadeira. Caso essa condição seja falsa, será então executado o bloco de instruções 2 em

vez do primeiro. De realçar que é sempre executado um dos blocos mas apenas um deles e

nunca os dois!!

Cuidado também com o facto de não existir ; antes da palavra reservada ELSE!!

Exemplos:

1) IF (x > 7) THEN writeln(x,‘ é maior que 7’) ELSE writeln(x,’ não é maior que 7’);

2) IF (odd(y))THEN writeln(y,’ é ímpar’) ELSE writeln(y,’ é par’);

Página 4

3) IF (x > 7 AND odd(y)) THEN BEGIN

writeln(x,‘ é maior que 7’); writeln(y,’ é ímpar’);

END ELSE BEGIN

writeln(x,‘ não é maior que 7’); writeln(y,’ é par’);

END;

4) IF (aux) THEN writeln(‘A variável aux tem valor TRUE’) ELSE writeln(‘A variável aux tem valor FALSE’);

2.3. Estrutura de escolha múltipla

A estrutura de escolha múltipla permite ao programa, com base no valor de uma variável

de controlo ou selector, escolher uma de várias alternativas possíveis em termos de instruções a

executar.

Esta estrutura, em Pascal, é a estrutura CASE… OF… e tem o seguinte diagrama sintáctico:

CASE Variável / Selector OF

Valor constante : Bloco de instruções ; END

,

ELSE Bloco de instruções ;

Usando esta estrutura, o programa irá procurar uma coincidência entre o valor da variável de controlo / selector e um dos valores constantes distribuídos pelas várias listas correspondentes

a cada uma das alternativas disponíveis, executando o bloco de instruções associado à lista onde

consta o valor igual ao do selector.

No caso do conteúdo do selector não corresponder a nenhum dos valores explicitados na

estrutura, nada será executado, ou então, será executado o bloco de instruções associado à cláusula

ELSE, se esta existir.

De salientar que a variável de controlo deverá ser do tipo Integer ou Char, e que as

constantes explicitadas na estrutura deverão ser do mesmo tipo que o selector.

1,2,3: writeln(x,’ é maior4: writeln(x,’ é igual

5,6: BEGIN writeln(x,’ IF (x=5) TH

é maiEN

ELSE writel END;

n(‘ o

Exemplos:

1) CASE x OF

que 0 e menor que 4’); a 4’);

Página 5

or que 4 e menor que 7’); teln(‘ o seu valor é 5 ’) seu valor é 6 ‘);

END; ELSE writeln(x,’ não pretence ao conjunto {1,2,3,4,5,6} ‘);

2) CASE x OF ‘a’ , ‘A’: result := n1 + n2; ‘s’ , ‘S’: result := n1 - n2; ‘m’ , ‘M’: result := n1 * n2; ‘d’ , ‘D’: result := n1 / n2;

END;

Vejamos agora um pequeno programa que simula uma calculadora aritmética através de uma

estrutura de escolha múltipla:

Program EXEMPLOdeCASE; {Simulador de uma calculadora aritmética} Var

X,Y : integer; OP : char;

Begin writeln (' Insira os dois operandos (inteiros): '); readln (X,Y); writeln (' Digite o operador para a operação pretendida: '); readln (OP); Case OP of

'+' : writeln (X + Y); '-' : writeln (X - Y); '*', 'x', 'X' : writeln (X * Y); '/', ': ' : writeln (X / Y:6:2); else writeln(' operador inválido ');

End; {fim da estrutura CASE} End.

É importante compreender que a estrutura CASE está limitada a situações em que a selecção é feita a partir de um conjunto de valores passíveis de representar em extensão (por exemplo

{1,2,3,4,5,6}). Em situações apenas representáveis em compreensão (por exemplo [0<x<2500])

então é preferível utilizar estruturas de decisão condicional.

2.4. Selecção encadeada

Página 6

Já vimos que, quando existem mais do que duas alternativas de acção, uma das possibilidades à disposição do programador é a estrutura CASE. No entanto, essa estrutura só pode ser usada se

podermos comparar o valor de uma variável selectora com uma lista finita de valores constantes.

Existem contudo situações em que tal não se verifica o que nos obriga a utilizar várias estruturas de

decisão condicional aninhadas umas dentro das outras.

Suponhamos que queremos dizer se um valor é maior, menor ou igual a zero. Temos três

alternativas distintas. No entanto neste caso não é possível usar a estrutura CASE uma vez que

existem demasiados valores para testar. Assim, a solução passa por aninhar estruturas IF. Vejamos

como fazê-lo no seguinte exemplo:

Program IFaninhados; {Determinar se um número é maior, menor ou igual a zero} Var

n : integer;

Begin Writeln(‘Insira um valor inteiro’); readln(n); if (n > 0) then

writeln (n,' é maior que zero' ) else

if (n < 0) then writeln (n,' é menor que zero')

else writeln (n,' é igual a zero');

End.

Também a título de exemplo, vejamos como poderíamos escrever com IFs aninhados o exemplo 1 apresentado para a estrutura CASE:

IF (x > 0) AND (x < 4) THEN writeln(x,’ é maior que 0 e menor que 4’) ELSE

IF (x = 4) THEN writeln(x,’ é igual a 4’) ELSE

IF (x > 4) AND (x < 7) THEN BEGIN

writeln(x,’ é maior que 4 e menor que 7’); IF (x=5) THEN writeln(‘ o seu valor é 5 ’) ELSE writeln(‘ o seu valor é 6 ‘);

END ELSE writeln(x,’ não pretence ao conjunto {1,2,3,4,5,6} ‘);

3. Estruturas de Repetição

Página 7

Em variadíssimos algoritmos será necessário repetir determinadas instruções várias vezes. Por exemplo, «Rodar a chave até a porta abrir» ou «Rodar a chave 3 vezes para abrir a porta».

Quer num caso quer noutro, a acção de rodar a chave será executada mais do que uma vez. Ora

para que um computador perceba que terá de efectuar várias vezes uma determinada instrução, os

programas usam aquilo a que se chama estruturas de repetição.

3.1. Estruturas de repetição condicionais

As estruturas de repetição condicionais são aquelas em que o número de repetições

depende de uma condição, ou seja, em que à partida o programador não pode saber quantas vezes

as instruções serão repetidas. Por exemplo, quando temos situações como «Rodar a chave até a

porta abrir» ou «Enquanto tiver fome, coma!», não se sabe quantas vezes se vai rodar a chave

ou quantas vezes se vai comer. Quer num caso quer noutro, as repetições estão dependentes da

verificação de uma condição.

Estas estruturas de repetição condicionais podem ser de dois tipos diferentes: Repetir… Até (condição) e Enquanto (condição) faça…

As principais diferenças entre elas são as seguintes:

° Na estrutura Repetir… Até (condição) as instruções que dela fazem parte são repetidas

até que a condição se verifique, ou seja, os ciclos terminam quando a condição

passar a verdadeira. Por outro lado, a condição é testada apenas no fim de cada

ciclo o que implica que pelo menos uma vez as instruções serão executadas

mesmo que a condição seja verdadeira logo da primeira vez que seja testada.

° Na estrutura Enquanto (condição) faça… as instruções são executadas enquanto a

condição se verificar, ou seja, os ciclos terminam quando a condição passar a falsa.

Por outro lado, a condição é testada logo no início de cada ciclo o que significa que

as instruções podem nem sequer ser executadas se a condição for falsa logo da

primeira vez que for testada.

Em Pascal, a estrutura Repetir… Até… corresponde à estrutura Repeat… Until… e o seu

diagrama sintáctico é o seguinte:

Página 8

REPEAT instrução UNTIL Condição ;

;

Esta estrutura é particularmente útil para validar inputs, repetindo a leitura dos mesmos até que estes obedeçam às condições que definem a sua validade. Vejamos alguns exemplos:

1) REPEAT writeln(’Insira um número de 1 a 15’); readln(x);

UNTIL (x < 1) AND (x > 15);

2) REPEAT writeln(’Sexo: [M/F]’); readln(x);

UNTIL (x = ‘M’) OR (x = ‘F’);

Em Pascal, a estrutura Enquanto… faça… corresponde à estrutura While… Do… e o seu

diagrama sintáctico é o seguinte:

WHILE condição DO Bloco de instruções ;

Vejamos alguns exemplos:

1) writeln(‘Introduza uma série de valores. Temine-a com 0’); readln(valor); WHILE (valor <> 0) DO BEGIN

writeln(’Insira um novo valor’); readln(valor);

END;

Nota: poderá usar variável auxiliar x:=1 e condição while x<>0

2) aux := true; WHILE aux DO BEGIN

writeln(’Introduza um número menor que 20’); readln(x); IF (x > 20) THEN aux := false;

END;

3.2. Estruturas de repetição incondicionais

Página 9

As estruturas de repetição incondicionais, ao contrário das anteriores, não se baseiam numa condição mas sim numa variável contadora. Quer isto dizer que o número de repetições é

controlado por uma contagem feita à base de uma variável cujo valor vai sendo actualizado em cada

ciclo. A variável contadora parte de um determinado valor inicial e vai mudando de valor até atingir

um determinado valor de chegada que implica o fim das repetições. Isto obriga a que o

programador possa determinar, à partida, o número de vezes que as instruções deverão

ser executadas, ou seja, quantos ciclos se pretendem executar.

Em Pascal, esta estrutura de repetição é normalmente designada por ciclo «For… to… do…» e tem o seguinte diagrama sintáctico:

FOR Variável contadora := Valor inicial

TO

DOWNTO

Valor final DO

Bloco de instruções ;

Como se pode constatar no diagrama, existem duas variantes distintas para esta estrutura: usando a palavra reservada TO ou usando a palavra reservada a DOWNTO. No primeiro caso, a

variável contadora é incrementada em cada ciclo, ou seja, vai crescendo desde o valor inicial até ao

valor final. No segundo caso, a variável contadora é decrementada em cada ciclo, ou seja, vai

decrescendo desde o valor inicial até ao valor final.

É importante notar que a actualização da variável contadora é feita automaticamente.

Não é utilizada nenhuma instrução explicitamente para isso!!

Exemplo:

Begin writeln (“Introduza um número”); readln (num); writeln (“Os primeiros 5 múltiplos desse número são:”); FOR cont := 1 TO 5 DO BEGIN

multiplo := num * cont; writeln (multiplo);

END; END.

No exemplo anterior, o programa executa 5 vezes as operações

multiplo := num * cont;

writeln (multiplo);

Página 10

uma vez que o contador varia desde 1 até 5. Por cada valor que o contador toma entre aqueles dois

limites, o ciclo é executado uma vez. Significa isso que os valores que o programa irá escrever serão

os cinco primeiros múltiplos do valor introduzido pelo utilizador.

Exercícios Resolvidos

1. Ler continuamente números a partir do teclado, até que seja digitado o valor zero.

Program exerc1; Var

n : integer; Begin

Repeat Readln(n);

Until (n=0); End.

2. Calcular a soma de cinco valores lidos a partir do teclado.

Program exerc2; Var

soma, v: real; conta : integer;

Begin soma := 0; For conta := 1 to 5 do Begin

End;

readln(v); soma := soma+v;

End.

writeln(‘Soma:’,soma);

3. a) Pretende-se mostrar, no ecrã, os números inteiros compreendidos entre 20 e 200.

Program exerc3;

Var n:integer;

Begin

For n := 20 To 200 do

writeln(n);

End.

b) Altere o programa para escrever por ordem decrescente.

Página 11

4. Supondo que o dia da semana é representado por 1, se for domingo; 2 se for segunda

e assim sucessivamente. Pedir ao utilizador que digite um valor e apresentar no ecrã o

dia da semana correspondente. Program exerc4;

Var dia:integer;

Begin

writeln(‘Introduza um valor numérico de 1 a 7:’);

readln(dia);

Case dia of

1:writeln(‘Domingo’);

2:writeln(‘Segunda’);

3:writeln(‘Terça’);

4:writeln(‘Quarta’);

5:writeln(‘Quinta’);

6:writeln(‘Sexta’);

7:writeln(‘Sábado’);

Else writeln(´Não existe dia da semana para esse valor’);

END.

End;

5. Dado uma série de valores representando as notas de alunos, elabore um algoritmo

que determine quantos tiveram nota positiva.

Algoritmo exerc5;

Variáveis n,nota,indice,contador:inteiros;

Início

Conta„0;

Escreve(‘Quantos alunos têm a turma?’);

Ler(n);

Para índice desde 1 até n faça

Início

Fim

Escrever(‘Introduza a nota do ‘,indice,´º aluno’);

Ler(nota);

Se nota >=10 então Conta„conta+1;

Escrever (‘Houve ‘, conta, ‘ positivas’);

Fim