Aula03_04 - Estruturas de Controlo

(1)

UNIVERSIDADE GREGÓRIO SEMEDO

Faculdade de Engenharia e Novas Tecnologias

Linguagem C

(2)

Estrutura de Controlo e de Fluxo Comandos de Seleção: O comando if; Ifs Aninhados; A escada if-else-if; A expressão condicional; Switch;

Comandos switch aninhados; Comandos de Interação: O laço for; O laço while; O laço do-while. 2/47

Sumário

(3)

As estruturas de Controlo são fundamentais para qualquer linguagem de programação;

Sem elas só haveria uma maneira do programa ser

executado: de cima para baixo, comando por comando; O padrão ANSI divide os comandos de C nestes

grupos: Seleção; Interação; Desvio; Rótulo; Expressão;

(4)

Muitos comando em C contam com um teste condicional que determina o curso da ação; Uma expressão condicional chega a um valor

verdadeiro ou falso.

Em C, um valor verdadeiro é qualquer valor diferente de zero, incluindo números negativos;

O valor falso é 0;

4/47

(5)

C suporta dois tipos de comandos de seleção: if e switch. Além disso o operador ? É uma alternativa ao if em certas circunstâncias.

A forma geral da sentença if é:

if(expressão)

{ comando; } else

{ comando; }

Onde comando pode ser um único comando, um bloco de

(6)

A expressão é avaliada. Se ela for verdadeira

(diferente de 0), o comando ou bloco que forma o corpo do if é executado;

Caso contrário, o comando ou bloco que é o corpo do else (se existir) é executado.

Lembre-se: Apenas o código associado ao if ou o código associado ao else será executado, nunca ambos;

6/47

(7)

Aqui representamos um exemplo de uso do comando if, veja:

(8)

A saída no console para o programa anterior será:

8/47

(9)

Pode-se também usar unicamento o comando if (sem else), veja:

(10)

10/47

(11)

A estrutura if-else-if é apenas uma extensão da estrutura if-else;

A sua forma geral é:

if(expressão) comando; else if(expressão) comando; else if(expressão) comando; ... else comando;

As condições são avaliadas de cima para baixo.

(12)

Embora seja tecnicamente correta, o recuo da escada if-else-if anterior pode ser excessivamente profundo.

Por essa razão, a escada if-else-if é geralmente recuada deste forma: if(expressão) comando; else if(expressão) comando; else if(expressão) comando; ... else comando; 12/47

O comando if-else-if

(13)

Vejamos um exemplo da escada if-else-if:

(14)

14/47

(15)

Em C, o controlador do if precisa, apenas, ser zero ou

não-zero, vejamos:

if(num2!=0)

(16)

16/47

(17)

A linguagem C tem um comando interno de seleção múltipla chamado switch;

O switch testa sucessivamente o valor de uma expressão contra uma lista de constantes inteiras ou de caracteres;

O comando switch

(18)

switch(variável ou constante) _{Sem ponto-e-vírgula}

{

case constante 1: _{Dois pontos}

instrução; instrução;

break; _{Geralmente, a última}

case constante 2: _{instrução é break, o que}

instrução; _{causa a saída imediata}

instrução; _{de todo o corpo do switch}

break; case constante 3: instrução; instrução; break; default: instrução;

instrução; Você não poderá usar uma variável ou uma expressão lógica como rótulo

break;

de um caso dentro de um switch

}

(19)

switch(variável ou constante) _{O corpo de cada caso poderá ser vazio}

{ _{ou conter um ou mais intruções, que}

case constante 1: _{não necessitam estar entre chaves.}

O corpo de um switch deve estar entre

break;

chaves.

case constante 2:

instrução;

instrução; _{Se o rótulo de um caso for igual ao valor}

break; _{da expressão do switch, a execução}

case constante 3: _{começará nele.}

Se nenhum caso for satisfeito e existir

break;

um caso default, a execução começará

default:

nele. Um caso default é opcional.

instrução;

(20)

Exemplo de utilização do switch:

getche()função usada para leitura de caracteres, um por vez, da entrada padrão.

Continua no próximo slide

Comum apenas para DOS

19/47

(21)

Exemplo de utilização do switch (Continuação):

(22)

21/47

(23)

O padrão ANSI C especifica que um switch pode ter pelo menos 257 comandos case;

Embora case seja um rótulo ele não pode existir sozinho, fora de um switch;

O comando break é um dos comandos de desvio em C. Pode usá-lo em laços tal como no comando switch;

Quando um break é encontrado em um switch, a execução do programa “salta” para a linha de código seguinte ao comando

(24)

Se o comando break for omitido, a execução do programa continua pelos próximos comandos case até que um break, ou o fim do switch seja

encontrado;

Ex: int x=0, op; scanf(“%d”, op);

switch(op) {

case 1: /*Nada*/ _Opção _x

case 2: 10 1 x= 10; break; 2 10 case 3: x++; ₃ ₁ case 4: 0 4 x++; default -1 default: x--; } 23/47

O comando switch

(25)

Há três observações importantes a saber sobre o comando switch:

switch só pode testar igualdade, enquanto que o if pode avaliar uma expressão lógica e/ou relacional;

Duas constantes case no mesmo switch não podem ter valores idênticos;

Se constantes de caractere são usadas em um comando switch, elas são automaticamente convertidas para seus valores inteiros;

(26)

Os comandos associados a cada case não são blocos de códigos mas, sim, seqüência de comandos. Vejamos em que essa distinção técnica influencia:

/* Incorreto */ /* Correto */

Switch (op) { Switch (op) {

case 1: case 1: int i; { ... int i; ... } 25/47

O comando switch

(27)

Podemos ter um switch como parte de uma seqüência de comandos de outro switch, vejamos:

Switch (x) { case 1:

Switch (y) {

case 0: printf(“\n10 em decimal eh 2”);

break; case 1: ...

}

case 2:

...

Não ocorre conflito com o case mais

(28)

Na linguagem C, comando de interação (também

chamados laços) permitem que um conjunto de

instruções seja executado até que ocorra uma certa condição;

As estruturas de repetição em C apresentam-se em 3

formas distintas: for while do-while 27/47

Comandos de Interacção

(29)

O laço for é a instrução mais poderosa na criação de estruturas de repetição;

Vejamos sua forma geral mais comum:

for(inicialização; condição; incremento)

{

comandos; }

Inicialização é, geralmente, um comando de atribuição que é usado

para colocar um valor na variável de Controlo do laço;

A condiçãoé uma expressão relacional que determina quando o laço acaba;

O incremento define como a variável de Controlo do laço varia cada

(30)

Ponto-e-vírgula

Inicialização Teste Incremento

for ( i=0 ; i < 20 ; i++ )

printf("%c" , '*');

Corpo _{Não há ponto-e-vírgula aqui}

(31)

As seções no comando for são separadas por

pontos-e-vírgulas;

Uma vez que a condição se torne falsa, a execução do programa continua no comando seguinte ao for,

vejamos:

(32)

30/47

(33)

Podemos utilizar outras estruturas de Controlo dentro do laço for, vejamos:

O comando if está

selecionando apenas os números ímpares

(34)

32/47

(35)

O mesmo programa anterior poderia ser escrito da seguinte forma:

i = i +2;

(36)

34/47

(37)

Uma das variações mais comuns do laço for usa o operador vírgula ( , ) para permitir que duas ou mais variáveis controlem o laço, veja:

int x, y;

for (x=0, y=0; x+y<10, x++)

{

y = getche();

x = y – ‘0’; /* Subtrai o código ASCII do caracter 0 de Y */ }

(38)

Além da sintaxe vista anteriormente, o laço for permite escrita de expressões mais elaboradas, vejamos:

36/47

(39)

(40)

Quando um laço for faz parte de outro laço for,

dizemos que o laço interno está aninhado. Vejamos:

saída 0 1 2 1 2 3 2 3 4 38/47

(41)

O segundo laço disponível em C é o laço while. A sua forma geral é: while (condição) { comando; }

comando é um comando vazio, um comando simples ou um bloco de comandos;

A condição pode ser qualquer expressão, e verdadeiro é qualquer valor não-zero;

O laço se repete quando a condição for verdadeira. Quando a condição é falsa, o Controlo do programa passa para a linha

(42)

O exemplo a seguir mostra uma rotina de entrada pelo teclado, que simplesmente se repete até que o utilizador digite n:

40/47

(43)

(44)

Ao contrário dos laços for e while, que testam a

condição do laço no começo, o laço do-while verifica a condição ao final do laço;

Portanto, o laço do-while será executado ao menos

uma vez;

A forma geral do lado do-while é:

do{

comando; } while (condição);

O laço do-while repete até que a condição se torne falsa.

42/47

(45)

Vejamos a principal diferença entre o laço do-while e o laço while:

int num = 101; int num = 101;

do{ while (num<100)

scanf(“%d”, &num); {

} while (num<100); scanf(“%d”, &num);

}

(46)

Talvez o uso mais comum do laço do-while seja em uma rotina de seleção por menu, vejamos:

44/47

(47)

(48)

46/47

(49)

Os comandos break e continue são instruções que devem pertencer ao corpo de um laço for, while ou do-while

Não podem ser utilizados em outras partes de um programa

O comando break tem um segundo uso que será analisado em seguida junto ao comando switch

O comando break causa a saída imediata de um laço

Em seguida, o Controlo passa para próxima instrução

Se a instrução break pertencer a um conjunto de laços aninhados, afetará somente o laço ao qual pertence e os laços internos a ele

(50)

/* Calculadora2.C */

/*Simula uma calculadora de 4 operações*/ /* Mostra o uso de break */

#include <stdio.h> #include <stdlib.h>

int main() {

const int TRUE=1;

while(TRUE) /* Sempre verdadeiro*/

{

float n1,n2; char op;

printf("\nDigite numero operador numero: "); scanf("%f%c%f", &n1, &op, &n2);

if( n1 == 0.0 ) break; /*Termina se Zero digitado*/

if( op == '+') printf("\n%f", n1 + n2); else if( op == '-') printf("\n%f", n1 - n2); else if( op == '*') printf("\n%f", n1 * n2); else if( op == '/') printf("\n%f", n1 / n2); else printf("\nOperador desconhecido."); }

printf("\nPrograma Finalizado. Tecle [ENTER] para sair."); getchar(); getchar();

(51)

O comando continue força a próxima iteração do laço e pula o código que estiver abaixo

Nos laços while e do-while, um comando continue faz com que o Controlo do

programa avalie imediatamente a expressão de teste e depois continue o processo do laço

No laço for, é executada a expressão de incremento e, em seguida, o teste

O exemplo a seguir imprime apenas os caracteres digitados no teclado que são diferentes de dígitos

(52)

/* SemDigitos.C */

/* Elimina impressão de dígitos */ /* Mostra o uso de continue */ #include <stdio.h>

#include <stdlib.h>

#include <conio.h> /* para getche()*/

int main()

{

char ch;

while ((ch=getch())!='X') /* Termina quando digitado X*/ {

if( ch >= '0' && ch <= '9') /*É dígito?*/

continue; /*Execute o teste novamente*/ printf("%c", ch);

}

printf("\nPrograma Finalizado. Tecle [ENTER] para sair."); getchar();

return 0;

(53)

O comando goto está disponível em C para fornecer alguma compatibilidade com outras linguagens

• Sua utilização não é aconselhada

• Esse comando causa o desvio do Controlo do programa para a instrução

• seguinte ao rótulo com o nome indicado

• Lembrando que um rótulo é um nome seguido de dois-pontos (:)

if(x == 0) goto erro; else r = n/x; ...

O comando GOTO

(54)

SCHILDT H. “C Completo e Total”, Makron Books. SP, 1997.

MIZRAHI, V. V. “Treinamento em Linguagem C++

Módulo 1”, Makron Books, SP, 1995.

FORBELLONE, A. L. V. “Lógica de Programação: A

construção de algoritmos e estruturas de dados”,

Prentice Hall, SP, 2005.

47/47