Decisões e Repetições

Decisões e Repetições

!

Decidir se uma seção de código deve ser executada

ou não ou o número de vezes que uma repetição

deve ser executada, depende do resultado de certas

expressões => verdadeiro ou falso => expressões

que em geral envolve uma espécie de operador

chamado de operador relacional.

!

Operador relacional compara dois valores. As

comparações envolvem relações do tipo, é igual,

menor que e maior que. O resultado dessas

comparações é verdadeiro ou falso.

Operador Significado

> Maior que

< Menor que

== Igual

!= Diferente

>= Maior ou igual

<= Menor ou igual

#include <iostream.h>

void main( )

{ int num;

cout<<“Entre com um número:”:

cin>>num;

cout<<“num<10 é “<< (num<10)<<endl

<<“num>10 é “<<(num>10)<<endl

<<“num==10 é “<<(num==10)<<endl;

}

Entre com um número: 20 num<10 é 0

!

Repetição usando while

sintaxe: while (expressão) ou while (expressão)

comando ; { comando 1;

comando 2; ...

comando n ;

}

!

Calcular o valor da primeira potencia de2 maior

que 1000.

!

Calcular a primeira potencia de 2 maior que 1000.

// programa para calcular a primeira potência de 2>1000

#include <iostream.h>

void main( )

{ int produto = 2;

while ( produto <= 1000 )

produto = produto * 2 ;

cout<<“primeira potencia de 2 maior que 1000=“

<<produto << endl ;

}

!

Exercício: Uma classe de 10 estudantes fez um teste. As

notas (valores entre 0 e 10) estão disponíveis. Faça um

!

Generalizar o problema, ou seja, usar o programa

para calcular a média de turmas com quaisquer

número de alunos.

!

_{Como e quando parar a leitura???}

!

Usar um “sentinela” ou “flag” que indique o fim dos

dados. Ele deve ser um valor que não pode ser

confundido com a entrada.

!

Para o nosso problema podemos usar um número

!

Formatação:

! setprecision(2) " indica que a variável após essa instrução deve ser escrita com dois dígitos depois do ponto.

! Setioflags(ios::fixed | ios:::showpoint) " duas opções de

formatação separadas pelo separador de opção |

! ios::fixed " formato de pt. Fixo, oposto da notação científica (xxxExx)

! ios::showpoint " força o pt. Decimal e imprime os dígitos depois do pt. Mesmo que sejam zero. Ex: 88.00 sem essa opção seria 88. Usando essas opções o valor é arredondado. Ex: 87.945 " 87.95

// media usando sentinela para controlar a repetição #include <iostream.h>

#include <iomanip.h> void main( )

{ float media, nota, soma_total = 0 ; int contador = 0;

cout<<“Entre com uma nota (-1 para terminar):”; cin>>nota;

while ( nota != -1)

{ soma_total = soma_total + nota ; contador = contador + 1 ;

cout<< “Entre com uma nota (-1 para terminar):”; cin>>nota;

}

if (contador != 0)

{ media = soma_total/contador ;

cout <<“Media da classe é:”<<setprecison(2) <<setiosflags(ios::fixed| ios::showpoint) <<media<<endl;

!

Controlador de uma repetição

1) o nome da variável de controle (ou contador

do loop);

2) O valor inicial da variável de controle;

3) A condição de teste para o valor final da

variável de controle ( ou seja, se o loop deve

ou não continuar)

4) O incremento (ou decremento) pelo qual a

variável vai ser modificada a cada passagem

do loop;

// repetição controlada por contador

#include <iostream.h>

void main( )

{ int contador = 1 ; //

while ( contador <= 10 ) // condição de teste

{ cout << contador << endl ;

++ contador ; // incremento

}

!

_{A estrutura de repetição for =>controla}

sozinha todos os detalhes do controlador de

repetição

expressão 1;

while (expressão 2)

{ comando;

expressão 3 ;

}

expressão 1 =>valor inicial da variável de controle

expressão 2 =>valor final da variável de controle

expressão 3 => incremento da variável de controle

!

Comando for => sintaxe

corpo da repetição com um único comando

b) for ( j = 0 ; j <15 ; j++ ) { comando ; comando ; comando ; } c o r p o d a r e p e t i ç ã o c o m múltiplos comandos

#include <iostream.h>

void main( )

{ for (int j=0; j<15; j++)

cout<< j * j <<“ “;

cout<<endl;

}

#include <iostream.h> void main( )

{ int soma = 0 ;

for ( int num = 2; num <= 100; num += 2) soma += num ;

cout << “A soma é :” << soma << endl ; }

#include <iostream.h> void main( )

{ for (int num = 2, int soma = 0; num <=100; soma+=num , num += 2) ;

!

As três expressões são opcionais:

! se expressão 1 é omitida # variável de controle foi iniciada em algum outro pt. do programa

! se expressão 2 é omitida # loop infinito

! se expressão 3 é omitida # incremento é calculado por

comandos dentro do corpo do for.

!

_{for (j=0, alfa=100; j<50; j++, beta--)}

!

_{for (; j>50; j--)}

!

Exercício: Uma pessoa investiu R$1000,00 numa

aplicação que rende 5% de juros por ano. Assumindo que

os juros permanecem na conta, calcule e imprima a

quantidade de dinheiro na conta ao final de 10 anos, ano

a ano. Use a seguinte fórmula para determinar esse valor:

a = p (1 + r)

onde :

p => é o investimento inicial

r => é a taxa de juros anual

n => é o número de anos

#include <iostream.h> #include <iomanip.h> #include <math.h> void main( )

{ double valor_final, valor_inicial = 1000.00, taxa = 0.05;

cout << “ANO”<< setw(18) << “VALOR NA CONTA” <<endl ;

for ( int ano = 1; ano <= 10; ano++)

{ valor_final = valor_inicial * pow (1.0 + taxa,ano); cout<< setw(3) << ano

<< setiosflags(ios::fixed | ios:: showpoint)

<< setw(18) << setprecision (2) << valor_final << endl ; }

ANO VALOR NA CONTA

1

1050.00

2 1102.50

3

1157.63

4 1215.51

5

1276.28

6

1340.10

7

1407.10

8

1477.46

9 1551.33

10

1628.89

!

Estrutura de repetição do… while ( semelhante ao repeat…

until do Pascal)

do do

comando { comando1; …

while (condição); comandon;

}

while (condição) ;

Exemplo:

#include <iostream.h>

void main ( )

{ int contador = 1;

do

cout << contador << “ “;

Decisões

!

As decisões em uma repetição sempre são

relacionadas a mesma questão: Deve executar o

corpo da repetição novamente?

!

_{Nos programas geralmente temos outros tipos de}

decisões, como dependendo de um resultado pulo

uma parte do programa, ou chamo uma função,

etc...

!

Forma mais importante comando if ... else. Este

!

O comando if

!

_sintaxe

if ( X > 100 )

{ comando;

comando único no corpo do if

if ( velocidade >= 120 ) comando;

comando; comando;

Múltiplos comandos no corpo do if Expressão teste

!

o comando if ... else

if ( X > 100 )

{ comando;

comando único no corpo do if

if ( velocidade >= 120 ) comando;

comando; comando; }

Múltiplos comandos no corpo do if Expressão teste

Expressão teste

else

comando;

comando único no corpo do else

else

{ comando;

!

if’s podem ser aninhados dentro de if’s e dentro

de repetições.

!

aninhando ifs dentre de repetições=> dado um

número determinar se ele é ou não primo.

!

_{aninhando if...else dentro de repetições => contar}

o número de palavras e caracteres numa frase

digitada pelo usuário

#include <iostream.h>

void main( )

{ unsigned long int n;

cout<<“Entre com um número:”;

cin >> n;

for (int j=2; j<n/2; j++)

if (n%j == 0)

{ cout << “nro não é primo: divisível por:”

<<j << endl;

exit (0);

}

#include <iostream.h> #include <conio.h> void main( )

{ int contchar = 0; //conta os caracteres ≠ espaço

int contpal = 1; //conta os espaços entre as palavras char ch = ‘a’; //para garantir que não será enter(\r) cout<<“Entre com uma frase:”;

while ( ch!=‘\r’) //repetição até encontrar \r { ch = getche( ) ; //lê um único caractere

if ( ch ==‘ ‘) contpal++; else

contchar++; }

!

O programa requer que o usuário tecle <enter> para

informar ao programa que a entrada foi completada.

!

A entrada é válida mesmo que o usuário digite nenhum

caractere ou um único.

!

_{O programa precisa processara cada caractere digitado}

pelo usuário até encontrar um <enter>

!

A função de biblioteca getche( ) faz esse serviço. Ela

retorna cada caractere digitado tão logo isso seja feito.

Deve ser incluido <conio.h>

!

_{A função getche( ) ecoa o caractere na tela. Uma outra}

função chamada getch( ) é semelhante ao getche( ) mas

não ecoa o caractere na tela.

#include <iostream.h> #include <conio.h> void main( )

{ int contchar = 0; //conta os caracteres ≠ espaço

int contpal = 1; //conta os espaços entre as palavras char ch ;

cout<<“Entre com uma frase:”;

while ( ( ch = getche( ) ) != ‘\r’) //repetição até encontrar \r if ( ch ==‘ ‘) contpal++; else contchar++; if (contchar!=0) contpal++ ;

! O comando switch => estrutura de seleção múltipla (semelhante ao case do Pascal) swtich ( n ) { case 1: comando; comando; break; case 2: comando; comando; break; case 3: comando; break; default: comando;

Inteiro ou variável caractere

Inteiro ou constante caractere

causa a saída do switch Corpo do primeiro case Corpo do segundo case Corpo do terceiro case

!

Em cada case temos um break. O break faz com

que termine o comando switch. Se não existir o

comando break, todos os comandos são executados

até o final do switch.

!

O rótulo default é opcional. Se o valor da

expressão não coincidir com nenhum rótulo,

executa os comandos a frente do default se existir,

senão não executa nada.

#include <iostream.h> void main( ) { int veloc; cout<<“Entre 33, 45 ou 78:”; cin>>veloc; switch (veloc)

{ case 33: cout<<“Rotação de LP”<<endl;break; case 45: cout<<“Compacto simples”<<endl;

break;

case 78: cout<<“Rotação obsoleta”<<endl; break;

#include <iostream.h> #include <conio.h> void main( ) { char dir=‘a’; int x=10,y=10; while (dir!=‘\r’)

{ cout<<“Sua posição é:”<<x<<“,”<<y<<endl; cout<<“Entre com a direção (N,S,L,O):”; dir=getche( );

switch (dir)

{ case ‘N’: case ’n’: y--; break; case ‘S’: case ‘s’: y++;break; case ‘L’: case ’l’: x++;break; case ‘O’: case ’o’: x--;break; }

!

Exercício: Na avaliação dos alunos da

pós-graduação não usamos notas e sim graus,

representados por A,B,C,D e E. Faça um programa

que receba como entrada os graus atribuídos a uma

turma de alunos da pós e mostre o total de cada

uma dos graus.

OBS: veja que não conhecemos o número de

alunos. Qual será o critério de parada?

#include <iostream.h> void main( )

{ int grau, conta_a=0,conta_b=0,conta_c=0,conta_d=0,conta_e=0; cout<<"Entre com as letras que representam as notas:" <<endl

<<"Digite EOF para terminar"<<endl; while ((grau = cin.get( ))!=EOF)

{ switch (grau)

{ case 'A':case 'a': conta_a++; break; case 'B':case 'b': conta_b++; break; case 'C':case 'c': conta_c++; break; case 'D':case 'd': conta_d++; break; case 'E':case 'e': conta_e++; break;

case '\n':case ' ': break ; // não faz nada

default: cout<<"Entrada não válida. Tente novamente"<< endl; break;

} }

cout<<endl<<"Total de cada grau"<<endl<<"A: "<<conta_a<<endl <<"B: "<<conta_b<<endl<<"C: "<<conta_c<<endl

min = (alfa < beta)? alfa : beta ;

!

Operador condicional=> onde existir um if da

forma: if ( alfa < beta )

min = alfa ;

else

min = beta ;

!

sintaxe:

resultado = (expressão de teste)? exp1:exp2 ;

!

while ((grau = cin.get( ) )!= EOF)

cin.get( )-> função que lê 1 caractere e armazena na

variável inteira grau. Após essa leitura compara o valor

lido com EOF

!

_{A notação do pt. Será vista quando falarmos de classes}

!

Caracteres são normalmente armazenados em variáveis

do tipo char. Na linguagem C++ podem ser armazenados

em variáveis inteiras. Pode ser tratado com caractere ou

como inteiro.

!

EOF -> acrônimo de End Of File-> constante simbólica

do tipo inteiro definida em iostream.h (normalmente –1).

Tecla que representa EOF: Unix:CTRL d, DOS:CTRL Z

!

O que faz o seguinte programa?

#include <iostream.h>

void main( )

{ for (int i=0; i<80; i++)

{ char ch = (i % 8)? ‘ ‘: ‘x’;

cout<< ch ;

}

}

Operadores Lógicos

!

and => && ; or => || ; not => !

!

_{Resumo dos operadores e precedência}

=, +=, -=, *=, /=, %= Atribuição ? : Condicional !, &&, || Lógicos <, >, <=, >= ==, != Relacional Aditivo: +, -Multiplicativo: *, /, % Aritméticos !, ++, , -Unário Operadores Tipo do operador

Outras Estruturas de Controle

! comando break => parada de execução.Além do uso no comando switch, pode ser usado dentro de uma repetição para forçar uma parada.

#include <iostream.h> #include <conio.h> void main( )

{ unsigned long n, j; bool eprimo=true;

cout<<"Entre com um numero:"; cin>>n; for (j=2; j<=n/2; j++)

if (n%j == 0)

{ cout<<"O nro "<<n<<" não é primo:é divisivel por “<j<<endl; eprimo=false; break;

}

!

_{Comando continue => dentro de uma repetição faz com o}

controle de execução volte para o topo

#include <iostream.h> #include <conio.h> void main( )

{ long dividendo, divisor; char ch; do

{ cout<<"Entre com o dividendo:"; cin>>dividendo; cout<<"Entre com o divisor:" ; cin>>divisor;

if (divisor ==0)

{ cout<<"Divisor não pode ser zero:"<<endl; continue;

}

cout<<"O quociente é: "<< dividendo/divisor<<endl;

cout<<"O resto da divisão é: "<< dividendo%divisor<<endl; cout<<"Repetir(S/N)?"; cin>>ch;