Sebenta Ling Prog Cptig   MóDulo Iii Carla
Upcoming SlideShare
Loading in...5
×
 

Sebenta Ling Prog Cptig MóDulo Iii Carla

on

  • 1,864 views

 

Statistics

Views

Total Views
1,864
Slideshare-icon Views on SlideShare
1,845
Embed Views
19

Actions

Likes
1
Downloads
47
Comments
0

1 Embed 19

http://apoiotic-carla.blogspot.com 19

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Sebenta Ling Prog Cptig   MóDulo Iii Carla Sebenta Ling Prog Cptig MóDulo Iii Carla Document Transcript

    • 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
    • Página 1 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)
    • 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.
    • Página 3 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’);
    • 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.
    • Página 5 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.
    • Página 6 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} ‘);
    • Página 7 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:
    • 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;
    • Página 9 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.
    • Página 10 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.
    • 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 Escrever(‘Introduza a nota do ‘,indice,´º aluno’); Ler(nota); Se nota >=10 então Conta„conta+1; Fim Escrever (‘Houve ‘, conta, ‘ positivas’); Fim