![]() |
![]() |
![]() |
Este capítulo trata das várias instruções do C utilizadas na construção de ciclos ou execução repetida (e controlada) de outras instruções.
![]() |
A instrução while
é semelhante à que
outras linguagens possuem. No entanto a utilização de uma expressão
genérica como controlo pode abrir novas possibilidades. A sintaxe geral da
instrução while
é:
while (expressão) instrução;
Um pequeno exemplo:
int x=3;
void main(void) { while (x > 0) { printf("x = %d\n", x); x--; } }
escreve no ecrã ...
x = 3
x = 2
x = 1
Uma vez que a instrução while
pode receber
uma expressão
geral em vez de apenas
uma condição
(o valor da expressão é interpretada como
TRUE se for diferente de 0, e como FALSE se for igual a 0), as instruções seguintes estão
todas corretas:
while (x--);
while (x = x + 1);
while (x += 5);
Usando qualquer das expressões mostradas, estas são avaliadas sucessivamente até atingirem o valor 0 (FALSE).
Outros exemplos:
while (x++ != 10);
while ((ch = getchar()) != 'q') putchar(ch);
O primeiro exemplo leva i
até 10. O segundo
usa as funções standard do
C getchar()
e putchar()
(declaradas
em stdio.h) que leem e escrevem um caractere respetivamente do teclado e para o ecrã.
O ciclo while
lê caracteres do
teclado e mostra no ecrã até que o utilizador insira um caractere 'q'.
![]() |
A instrução do-while
testa a expressão que
dela faz parte depois de executar as instruções do ciclo e continua enquanto se mantiver
em TRUE. O ciclo é executado pelo menos 1 vez. A sua sintaxe é:
do instrução; while (expressão);
O seguinte código:
int x = 3;
void main(void) do { printf("x = %d\n", x--); while (x > 0); }
escreve ...
x = 3
x = 2
x = 1
![]() |
A sintaxe da instrução for
é diferente do
habitual em outras linguagens. Uma instrução for
é
então definida como:
for (expressão1; expressão2; expressão3) instrução;
A expressão1
é o inicializador,
a expressão2
constitui o teste de terminação, e
a expressão3
é o modificador (é executada em cada
ciclo e pode fazer mais do que um simples incremento ou decremento).
A instrução for
é equivalente a um
ciclo while
com a seguinte construção:
expressão1; while (expressão2) { instrução; expressão3; }
Por exemplo, o seguinte código:
int x;
void main(void) { for (x=3; x>0; x--) printf("x = %d\n", x); }
escreve no ecrã ...
x = 3
x = 2
x = 1
As próximas instruções for
estão
todas corretas:
for (x = 0; x <= 9 && x != 3; x++);
for (x = 0, y = 4; x <= 3 && y < 9; x++, y += 2);
for (x = 0, y = 4, z = 1000; z; z /= 10);
Reparar no uso do operador ,
para
executar múltiplas ações. No terceiro ciclo, a execução continua até que
z
se torne 0 (FALSE).
![]() |
As instruções break
e continue
permitem-nos controlar a melhor forma de executar ciclos:
break
- termina imediatamente a execução de
um ciclo ou da instrução switch
continue
- salta imediatamente para a
avaliação da expressão de controlo do cicloNo exemplo seguinte pretende ler-se uma série de inteiros a partir do teclado e realizar operações. No entanto se o valor lido for o 0 terminamos a leitura; se o valor for negativo escrevemos uma mensagem de erro e terminamos o ciclo; e se for maior do que 100 ignoramos esse valor e passamos à leitura do próximo valor:
while (scanf("%d", &value) && value != 0)
{
if (value < 0)
{
printf("Valor ilegal\n");
break;
}
if (value > 100)
continue;
...;
/* processar value */
...;
}
A função scanf()
lê valores do teclado e
coloca-os em variáveis. Retorna o número de caracteres lidos se tiver sucesso e 0 no
caso contrário. Assim, se houver uma leitura, ela retorna um valor diferente de 0, que é
interpretado como TRUE.
![]() |
Exemplo:
[Entrada] | [Saída] | |
---|---|---|
10 | 1234 | 1234 |
8 | 77 | 63 |
2 | 1111 | 15 |
Se o valor for par deverá dividi-lo por 2, se for ímpar deverá multiplicá-lo por 3 e somar 1.
Quando o resultado atingir o valor 1, a sequência termina. O programa deverá apresentar todos os valores digitados, assim como o tamanho da sequência. Exemplo:
Valor inicial: 9
Próximo: 28
Próximo: 14
Próximo: 7
Próximo: 22
Próximo: 11
Próximo: 34
Próximo: 17
Próximo: 52
Próximo: 26
Próximo: 13
Próximo: 40
Próximo: 20
Próximo: 10
Próximo: 5
Próximo: 16
Próximo: 8
Próximo: 4
Próximo: 2
Próximo: 1
Gerada uma sequência de tamanho 20.
![]() |