Métodos Computacionais. Comandos Condicionais e de Repetição em C - PDF
Download "Métodos Computacionais. Comandos Condicionais e de Repetição em C"
Felícia Vidal de Vieira
1 Métodos Computacionais Comandos Condicionais e de Repetição em C
2 Tópicos da Aula Hoje vamos acrescentar comportamentos mais complexos a programas em C Comandos Condicionais if-else switch Comandos de Repetição for while do-while Comandos de Desvio break continue 2
3 Comandos Condicionais Um comando condicional nos permite escolher qual deve ser a próxima instrução executada em um programa A execução de uma determinada instrução depende de uma condição (expressão booleana) A linguagem C oferece 3 tipos de comandos condicionais: if else switch comando ternário (operador condicional) 3
4 O comando if-else if (expressaobooleana) { comandos else { outros comandos Se a avaliação de expressaobooleana retornar verdadeiro, comandos são executados, caso contrário, executa-se outros comandos 4
5 Exemplo do if-else #include <stdio.h> int main ( ) { float n1, n2, n3, m; printf ( \nentre com 3 notas ) ; scanf ( %f %f %f, &n1, &n2, &n3); m = (n1 + n2 + n3 ) / 3 ; if (m >= 7.0) { printf ( \n Aluno aprovado. ) ; printf ( Média igual a %f, m) ; else { printf ( \n Aluno reprovado. ); printf ( Média igual a %f, m) ; return 0; 5
6 Variações do comando if-else if (expressaobooleana) { comandos if (expressaobooleana) comando; if (expressaobooleana) comando; else outrocomando; Se a avaliação da expressão retornar falso, não executa-se nada O uso do bloco só é necessário caso queira-se executar mais de um comando 6
7 Exemplo if sem else #include <stdio.h> int main ( ) { int resposta ; printf ( \n Qual o valor de ? ); scanf ( %d, &resposta); if (resposta == ) printf ( \n Resposta correta! ); return 0; else não é obrigatório 7
8 Exemplo if-else com único comando #include <stdio.h> int main ( ) { int num ; printf ( \ndigite um número: ); scanf ( %d, &num); if (num < 0) else printf ( \n Número é negativo! ); printf ( \n Número é positivo! ); return 0; 8
9 Aninhando if-else if (expressaobooleana) if (expressaobooleana) comando; else outrocomando; if-else aninhado O comando dentro do if ou else pode ser outro if Num aninhamento, o else é associado ao mais recente if sem else 9
10 Exemplo if-else Aninhado Exercício: O que está errado neste programa? #include <stdio.h > int main () { int temp ; printf ( \n Digite a temperatura: ) ; scanf ( %d, &temp) ; if (temp < 30) if (temp > 20) printf ( \n Temperatura agradável ) ; else printf ( \n Temperatura muito quente ) ; return 0 ; 10
11 Exemplo if-else Aninhado Exercício: Corrigindo o programa #include <stdio.h > int main () { int temp ; printf ( \n Digite a temperatura: ) ; scanf ( %d, &temp) ; if (temp < 30) { if (temp > 20) printf ( \n Temperatura agradável ) ; else printf ( \n Temperatura muito quente ) ; return 0 ; else associado ao if certo 11
12 Encadeando comandos if-else if (expressaobooleana) { comandos else if (expressaobooleana ) { comandos else { comandos 12
13 Tomando Múltiplas Decisões O comando if-else é útil para a escolha de uma entre duas alternativas Quando mais de duas alternativas são necessárias, pode ficar deselegante utilizar vários if-else encadeados Para estes casos o comando switch pode ser a melhor opção 13
14 O Comando switch switch(expressao) { case rotulo1: Comandos1 break; case rotulo2: Comandos2 break;... default: Comandos Para executar um switch Avalia-se expressao Executa-se os comandos do case cujo rótulo é igual ao valor resultante da expressão Executa-se os comandos de default caso o valor resultante não seja igual a nenhum rótulo
15 Restrições do Comando switch switch(expressao) { case rotulo1: Comandos1 break; case rotulo2: Comandos2 break;... default: Comandos O tipo de expressao só pode ser : Inteiro ou caractere Os rótulos são constantes diferentes Existe no máximo uma cláusula default (é opcional) Os tipos dos rótulos têm que ser o mesmo de expressao
16 Variações do Comando switch switch(expressao) { case rotulo1: Comandos1 break; case rotulo2: Comandos2 break;... default: Comandos execução dos comandos até chegar ao final ou a Vários rótulos podem estar associados ao mesmo comando Os comandos break são opcionais: Sem o break a de um rótulo continua nos comandos do próximo, um break
17 Exemplo de switch Calcular a diferença, o produto, o quociente ou a soma de dois números, dependendo da operação escolhida e imprimir o resultado. # include stdio.h int main (void ) { char x; int a, b ; float result = 0.0; printf ( \n Informe os 2 números e a operação ); scanf ( %d %d %c, &a, &b, &x); 17
18 Exemplo de switch (cont..) switch (x) { case + : result = a + b; break; case - : result = a - b; break; case * : result = a * b; break; case / : result = a / b; break; default : printf( \noperador invalido ); printf ( \nresultado igual a %f, result); return 0 ; 18
19 Operador Condicional -? Forma Geral do? condição? expressão1 : expressão2 Substitui construções do tipo: if ( a > b ) { maximo = a; else { maximo = b; maximo = a > b? a :b ; 19
20 Comando Ternário de Decisão -? Exercício: Considere as seguintes declarações char a = a, b = b ; /*b tem valor 98*/ int i = 1, j = 2 ; double x = 7.07 ; Expressão i == j? a-1: b + 1 j % 3 == 0? i + 4 : x j > 1? j - 1 : j + 1 j % 3!= 0? i + 4: x Valor c
21 Estruturas de Repetição Permite repetir diversas vezes um comando ou seqüência de comandos Cada repetição de um comando ou seqüência de comandos é denominada de iteração São geralmente conhecidos como loops(laços) Da mesma forma que comandos condicionais, são controladas por expressões booleanas C oferece 3 tipos de estruturas(comandos) de repetição: O laço for O laço while O laço do-while 21
22 O Comando for for (i = 0; i < valor; i = i+1) corpo Executa corpo um número específico de vezes: valor vezes Neste exemplo, na primeira execução de corpo, o valor de i é 0 O valor de i é incrementado após cada execução de corpo Variável i deve ser declarada antes de se utilizar o comando for Variável de controle 22
23 A Forma Geral do Comando for for(inicialização;condição;incremento) corpo inicialização e incremento podem ser praticamente quaisquer comandos condição pode ser qualquer expressão booleana Inicialização geralmente inicializa a variável de controle do for incremento geralmente incrementa a variável for 23
24 Fluxo de Controle do Laço for inicialização condição avaliada true false comando incremento 24
25 Examinando o Comando for A inicialização é executada uma só vez antes do laço começar O comando é executado até que condição se tornar falsa for ( inicialização ; condição ; incremento ) comando; Cabeçalho do for O incremento é executado ao fim de cada iteração 25
26 Entendendo o Comando for int somatorio(int n) { int valor; int soma = 0; Variável valor é inicializada com 0 for (valor = 0; valor <= n; valor++) soma = soma + valor; return soma; A cada Comando será iteração, realizado valor é enquanto incrementado valor for em 1 menor ou igual a n 26
27 Entendendo o Comando for int somatorio(int n) { int valor; int soma = 0; Éexecutado depois do for Se n for menor do que 0, não se executa o corpo do for for (valor = 0; valor <= n; valor++) soma = soma + valor; return soma; 27
28 Entendendo o Comando for int somatorio(int n) { int soma = 0; int valor; for (valor = 0; valor <= n; valor++){ soma = soma + valor; printf( Soma Parcial:%d\n,soma); printf( Soma Total:%d,soma); return soma; Corpo do for pode ser composto por bloco de comandos 28
29 Modificando o Incremento do for valor agora é int somatorio(int n) { decrementado int soma = 0; int valor; for (valor = n; valor>= 0; valor--){ soma = soma + valor; printf( Soma Parcial:%d\n,soma); printf( Soma Total:%d,soma); return soma; 29
30 Modificando o Incremento do for int somatoriopares(int n) { int soma = 0; int valor; for (valor = 0; valor <= n; valor = valor + 2){ soma = soma + valor; printf( Soma Parcial:%d\n,soma); printf( Soma Total:%d,soma) return soma; valor agora é incrementado em 2 Pode-se colocar qualquer tipo de expressão na parte de incremento do comando for 30
31 Variações do Comando for Cada expressão no cabeçalho de um laço for loop é opcional Se a inicialização é inicialização é feita omitida, nenhuma Se a condição é omitida, a condição é considerada sempre verdadeira e o laço continua para sempre (laço infinito) Se o incremento é omitido, nenhuma operação é realizada ao final da iteração do laço 31
32 O Comando for sem Condição, etc. for(;valor < n; valor++) corpo for(;;valor++) corpo Repetição infinita: cuidado! for(;;) corpo 32
33 Mais Variações do Comando for Teste condicional não precisa ser baseado na variável de controle #include <stdio.h> #include <conio.h> int main ( ) { int i ; /* atribui um valor inicial a ch*/ char ch = a ; for(i = 0; ch!= q ;i++){ printf ( \npasso:%d,i) ; ch = getche() ; condição não é baseada na variável de controle 33
34 Mais Variações do Comando for Parte de incremento não precisa incrementar variável de controle Comando for pode vir sem corpo #include <stdio.h> #include <conio.h> int main ( ) { char ch; for(ch = getche(); ch!= q ;ch = getche()); printf ( \nvalor q encontrado ) ; Não tem corpo Incremento pode ser outro tipo de expressão 34
35 O comando while while (condição) corpo Executa corpo várias vezes até que a avaliação da expressão retorne falso A condição é avaliada de novo após cada execução de corpo Não executa corpo nenhuma vez, se de início a avaliação da condição retorna falso 35
36 Fluxo de Controle do Laço while condição avaliada true false comando 36
37 Entendendo o comando while int somatorio(int n) { int soma = 0; int valor = 0; while ( valor <= n ){ soma = soma + valor; valor++; return soma; Se n for negativo, não se executa o corpo do while Éexecutado quando o while termina, quando a condição for falsa 37
38 Entendendo o comando while int somatorio(int n) { int soma = 0; int valor = 0; while ( valor <= n ){ soma = soma + valor; valor++; return soma; Inicialização da variável de controle é feita fora do laço while Incremento da variável de controle é feita no corpo do laço while 38
39 Laço Infinito com o Comando while int somatorio(int n) { int soma = 0; int valor = 0; while ( valor <= n ){ soma = soma + valor; return soma; Se valor não é incrementado, este comando será executado infinitas vezes 39
40 O Comando for e o Comando while for(inicialização;condição;incremento) corpo equivale a... inicialização; while(condição) { corpo; incremento; 40
41 O Comando for e o Comando while for(;;) corpo while(1) { corpo; equivale a... 41
42 O Comando do-while do { corpo while(condição) Executa corpo, pelo menos uma vez, até que a avaliação da condição retorne falso A condição é avaliada de novo após cada execução de corpo 42
43 Fluxo de Controle do Laço do-while comando true condição avaliada false 43
44 Entendendo o comando do-while int somatorio(int n) { int soma = 0; int valor = 0; do { soma = soma + valor; valor++; while ( valor <= n ) return soma; Éexecutado quando o do-while termina, quando a condição for falsa Se n for negativo, o corpo do do-while é executado pelo menos uma vez Comportamento alterado: cuidado! 44
45 Os Comandos do-while e while do { corpo while(condição) Equivalente a... corpo; while(condição) corpo; 45
46 Laços Aninhados Laços podem ser aninhados da mesma forma que comandos condicionais O corpo de um laço pode conter outro laço Para cada iteração do laço externo, o laço interno é completamente executado 46
47 Laços Aninhados int somatoriodosomatorio(int n, int vezes) { int soma = 0, somatorio =0; int valext; for (valext = 0; valext < vezes; valext++ ){ int valint = 0; while (valint <= n) { soma = soma + valint; valint++; somatorio = somatorio + soma; return somatorio; A cada iteração do for, o laço while é executado 47
48 Considerações sobre Laços Os 3 tipos de laços são funcionalmente equivalentes Portanto podem ser usados indiscriminadamente Os laços for e while são executados 0 ou muitas vezes O laço do-while é executado 1 ou muitas vezes 48
49 O Comando break Forma Geral do comando break break; Tem dois usos distintos Para forçar o término de um laço de repetição (do-while, for ou while) Para terminar um case do comando switch Quando o comando break é encontrado dentro de um laço de repetição: instrução é imediatamente finalizada próxima instrução após a estrutura de repetição é executada Deve ser usado com cautela Reduz legibilidade Pode levar a erros de lógica 49
50 O Comando break int somatorio(int n) { int soma = 0; int valor; for (valor = 0; ; valor++){ soma = soma + valor; if (valor == n) break; Este comando não será executado quando valor = = n printf( Soma Parcial:%d\n,soma); printf( Soma Total:%d,soma) return soma; 50
51 O Comando continue Forma Geral do comando continue continue Termina a execução da iteração atual de um loop (for,while,do-while) e volta ao começo deste loop Todos os comandos que seriam executados após o continue são descartados 51
52 Comando de Desvio - continue Para os comandos while e do-while, o continue causa: a realização imediata do teste da condição correspondente continuidade do processo de repetição dependendo do resultado do teste Para o comando for, o continue causa: incremento da variável de controle do laço de repetição execução do teste para verificação da condição continuidade do processo de repetição dependendo do resultado do teste 52
53 O Comando continue void imprimenumerosatecinco() { int valor; for (valor = 0; valor <= 5; valor++){ if (valor == 4) continue; printf( %d,valor); Controle pula para o incremento e este comando não será executado quando valor = = 4 A saída desta função será:
54 O Comando continue void imprimenumerosatecinco() { int valor = 0; while (valor <= 5){ if (valor == 4) continue; printf( %d,valor); valor++; Controle pula para o teste e função tem execução infinita quando valor = = 4 A saída desta função será: laço infinito 54
Aula 05 Estruturas de controle em PHP. Prof. Pedro Baesse
Aula 05 Estruturas de controle em PHP Prof. Pedro Baesse pedro.baesse@ifrn.edu.br Comandos Condicionais Comandos de Repetição Comando de Fluxo de Execução Comandos usados para estruturar seus programas
SISTEMAS DE PROGRAMAÇÃO I UNIDADE 2 PROGRAMAÇÃO BÁSICA EM C
SISTEMAS DE PROGRAMAÇÃO I UNIDADE 2 PROGRAMAÇÃO BÁSICA EM C TURMA: º Período DISCIPLINA: Sistemas Embarcados I PROFESSOR: Pedro Pacheco Bacheti pedro.exercicios@gmail.com www.sites.google.com/site/professorengpedro
Aula 4. Comandos de Repetição. Prof. Filipe Mutz.
Aula 4 Comandos de Repetição Prof. Filipe Mutz. Instrução Instrução Instrução... Instrução Instrução Condicional (seleção) Repetitivo (loops) Comandos de repetição permitem que um conjunto de instruções
O laço for é geralmente usado quando queremos repetir algo por um número fixo de vezes
Linguagem C Laços Laços Laços são comandos usados sempre que uma ou mais instruções tiverem de ser repetidas enquanto uma certa condição estiver sendo satisfeita Em C existem três comandos de laços for