Sebenta Ling Prog Cptig MóDulo Iii Carla

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

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)

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

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’);

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.

Exemplos:

1) CASE x OF
1,2,3: writeln(x,’ é maior que 0 e menor que 4’);
4: writeln(x,’ é igual a 4’);
5,6: BEGIN
writeln(x,’ é maior que 4 e menor que 7’);
IF (x=5) TH EN teln(‘ o seu valor é 5 ’)
ELSE writel n(‘ o seu valor é 6 ‘);
END;
ELSE writeln(x,’ não pretence ao conjunto {1,2,3,4,5,6} ‘);
END;
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

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

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:

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

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
Valor final DO Bloco de instruções ;
DOWNTO

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);

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
readln(v);
soma := soma+v;
End;
writeln(‘Soma:’,soma);
End.

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.

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
Escrever(‘Introduza a nota do ‘,indice,´º aluno’);
Ler(nota);
Se nota >=10 então Conta„conta+1;
Fim
Escrever (‘Houve ‘, conta, ‘ positivas’);
Fim

Sebenta Ling Prog Cptig MóDulo Iii Carla

Mais conteúdo relacionado

Mais procurados (18)

Destaque (6)

Semelhante a Sebenta Ling Prog Cptig MóDulo Iii Carla (20)

Último (20)

Sebenta Ling Prog Cptig MóDulo Iii Carla