Introdução
Ciclos
Os ciclos servem para executar a mesma lógica repetidamente.
Os dois tipos mais comuns são o while loop (repetição indefinida) e o for loop (repetição definida, ou contada).
Há também o ciclo for each, que vais encontrar num conceito mais adiante.
Sintaxe geral
O for loop é composto por um cabeçalho e por um bloco de código que contém o corpo do ciclo entre chavetas.
O cabeçalho é composto por 3 componentes separados por pontos e vírgulas ;: a instrução de inicialização, a condição e outra expressão.
Qualquer um deles pode estar vazio.
for (init_statement; condition; expression) {
some_statement;
}
- O componente instrução de inicialização é código que corre apenas uma vez, antes de o ciclo começar.
- O componente condição tem de ser uma expressão que seja avaliada como um
boolean e que controla quando o ciclo deve parar.
O código dentro do ciclo corre enquanto esta condição for avaliada como true.
Assim que esta expressão for avaliada como false, deixa de haver novas iterações do ciclo.
- O componente expressão é código que corre no fim de cada iteração.
O while loop executa o seu corpo enquanto a verificação da condição for true.
O excerto de código abaixo mostra como transformar um for num while loop.
init_statement;
while(condition) {
some_statement;
expression;
}
Interlúdio: incrementos e decrementos
Quando trabalhas com ciclos, é frequente teres de somar ou subtrair 1 a uma variável contadora que acompanha as iterações.
Isto é tão comum que as operações de incremento e decremento têm operadores especiais: ++ e --.
Existem na forma prefixada e na forma pós-fixada.
A forma prefixada altera a variável antes de esta ser usada na instrução; a forma pós-fixada altera-a depois.
Na maior parte das vezes, vais provavelmente querer a versão prefixada.
int a{3};
int b{--a};
// b is 2, a is now 2
int c{a++};
// c is 2, a is now 3
Ciclos for: um exemplo
O componente de inicialização costuma criar uma variável contadora, a condição verifica se o ciclo deve continuar ou parar e o componente posterior incrementa normalmente o contador no fim de cada repetição.
int sum{0};
for (int i{1}; i < 10; ++i) {
sum += i;
}
Este ciclo soma os números de 1 a 9 (incluindo o 9).
Break e continue
Dentro do corpo de um ciclo, podes usar a palavra-chave break para interromper completamente a execução do ciclo:
int sum{2};
while(true) {
sum *= 2;
if (sum > 1000)
break;
}
// sum is now 1024
Em contrapartida, a palavra-chave continue apenas interrompe a execução da iteração atual e passa à seguinte:
int equal_sum{0};
for (int i{1}; i < 7; ++i) {
if (i%2 == 1) {
continue;
}
equal_sum += i;
}
// equal_sum is now 12
Normalmente é mais fácil compreender a lógica do ciclo quando o uso de break e continue é minimizado ou evitado por completo.
Ambas as palavras-chave saltam certas secções do código e tornam-no muitas vezes mais difícil de acompanhar.
Instruções
Neste exercício, vais trabalhar com contas poupança.
Todos os anos, o saldo da tua conta poupança é atualizado com base na respetiva taxa de juro.
A taxa de juro que o teu banco te dá depende da quantia de dinheiro na tua conta (o respetivo saldo):
- 3,213% para um saldo inferior a
0 dólares (o saldo fica ainda mais negativo).
- 0,5% para um saldo maior ou igual a
0 dólares e inferior a 1000 dólares.
- 1,621% para um saldo maior ou igual a
1000 dólares e inferior a 5000 dólares.
- 2,475% para um saldo maior ou igual a
5000 dólares.
Tens quatro tarefas, e cada uma delas envolve o saldo e a respetiva taxa de juro.
1. Calcula a taxa de juro
Implementa a função interest_rate para calcular a taxa de juro com base no saldo indicado:
interest_rate(200.75);
// => 0.5
2. Calcula os juros
Implementa a função yearly_interest para calcular os juros com base no saldo indicado:
yearly_interest(200.75):
// => 1.003750
3. Calcula a atualização anual do saldo
Implementa a função annual_balance_update para calcular a atualização anual do saldo, tendo em conta a taxa de juro:
annual_balance_update(200.75);
// => 201.75375
4. Calcula os anos até atingir o saldo desejado
Implementa a função years_until_desired_balance para calcular o número mínimo de anos necessários para atingir o saldo desejado, tendo em conta que, todos os anos, são adicionados juros ao saldo.
Isto significa que o saldo após um ano é: saldo inicial + juros sobre o saldo inicial.
O saldo após o segundo ano é o saldo após um ano + juros sobre o saldo após um ano.
E assim sucessivamente, até que o saldo do ano atual seja maior ou igual ao saldo desejado.
double balance {200.75};
double targetBalance {214.88};
years_until_desired_balance(balance, targetBalance)
// => 14
Repara que o valor devolvido é um int.
Exercício de aprendizagem
