<Direto ao Ponto 43> Os comandos de repetição

Artigos desta série: ( < ) Anterior | Índice | Seguinte ( > )

Olá, dev!

Este é mais um artigo da série DIRETO AO PONTO, que eu estou escrevendo para a DIO. Ele vai tratar sobre mais um dos blocos de programação com comandos múltiplos, os comandos de repetição.

Sumário

1. Introdução

2. Algoritmo para um comando de repetição

3. Comandos de repetição atuais

4. Considerações finais

5. Referências

1 – Introdução

Eu criei a série de artigos DIRETO AO PONTO com o objetivo de apresentar, de forma simples e direta, conhecimentos básicos da programação e de computação, principalmente, para os iniciantes.

Aqui, são tratados de temas como lógica de programação, linguagens, hardware dos computadores, história da computação e assuntos relacionados à plataforma da DIO, como a escrita de artigos e os desafios de código.

Neste artigo, eu vou falar sobre os comandos (instruções) de repetição, mais um dos blocos de programação com comandos múltiplos, além dos comandos de seleção, tratados no artigo anterior.

Vamos ver o que podemos fazer com eles.

2 – Algoritmo para um comando de repetição

Muitas vezes, precisamos executar os mesmos comandos mais de uma vez, por exemplo, para ler inúmeros dados de entrada, calcular a mesma expressão várias vezes, ou tratar elementos de um vetor (lista) ou de uma matriz.

Para evitar a repetição dos mesmos comandos, pode-se usar uma estrutura que permite executá-los, repetidamente, cada iteração com novos dados.

Os comandos de repetição existem desde as primeiras linguagens de programação e já apareceram várias formas diferentes para sua implementação.

Basicamente, podemos separá-los em 2 tipos principais:

·        O teste de parada é feito no início do bloco;

·        O teste de parada é feito no final do bloco;

As figuras abaixo mostram os dois tipos.

No lado esquerdo, o teste de parada é realizado antes de serem executadas as instruções contidas no bloco. Se o teste inicial resultar falso, nenhuma das instruções do bloco será executada e o fluxo passa para a próxima instrução logo após o bloco de repetição.

No lado direito, o teste de parada é realizado no final do bloco, após uma execução de todas as instruções contidas no bloco. Se o teste inicial, realizado no final der falso, o bloco se encerra e a próxima instrução a ser executada é a primeira instrução imediatamente após o bloco de repetição.

Veja que no primeiro caso, pode ser que nenhuma instrução do bloco de repetição seja executada. Já no segundo caso, todas as instruções do bloco de repetição serão executadas pelo menos uma vez.

Um algoritmo simples para um bloco de repetição pode ser o seguinte:

Primeiro caso:

Teste a condição de parada

Se verdadeira,

. Execute as instruções do bloco

. Atualize a variável do teste

Caso contrário

. Passe para a próxima instrução após o bloco

Segundo caso:

Execute as instruções do bloco

Atualize a variável do teste

Teste a condição de parada

Se verdadeira

. Volte ao início e repita todo o processo

Caso contrário

. Passe para a próxima instrução após o bloco

Note que eu destaquei explicitamente uma instrução para atualizar a variável usada no teste. Ela faz parte das instruções contidas no bloco. Esse passo é imprescindível para que um bloco de repetição funcione direito, caso contrário, o resultado do teste seria sempre o mesmo e o programa estaria em loop infinito.

Um programa em loop infinito não deixa tempo livre nem abre espaço para que outro programa do computador seja executado em paralelo, nem mesmo aqueles do sistema operacional.

Assim, o computador ficaria travado, precisando que o usuário intervenha para matar o processo do programa (no caso de Linux ou Unix, por exemplo) ou reiniciar o computador (CTRL+ALT+DEL, em Windows), causa da famosa mensagem: “Esse programa não está respondendo!”

Veja o exemplo a seguir de bloco de repetição, usando comandos da linguagem Scratch. Ele mostra o comando de repetição “Repita até que” com o teste de parada “chute = segredo ou tentativa > 4” e as instruções que fazem parte do bloco (destacadas pelo contorno em vermelho), que serão repetidas durante as iterações:

Quando não eram oferecidos comandos de repetição pelas linguagens mais antigas, as iterações podiam ser simuladas por um conjunto de instruções simples (em FORTRAN), usando o comando GOTO:

  MAX = 4
  CONT = 1
  SOMA = 0
100    IF CONT .GT. MAX GOTO 200
  SOMA = SOMA + CONT
         CONT = CONT + 1
         GO TO 100
200    WRITE *, SOMA

Explicação da execução:

Após a inicialização das variáveis, é feito um teste para checar se CONT (que conta o número de iterações realizadas) já ultrapassou o número máximo de iterações permitidas (MAX).

Caso ele não seja ultrapassado, as instruções constantes do bloco serão executadas. O valor da iteração atual é somado à uma variável (SOMA), que acumula esta soma a cada iteração. Finalmente, o valor da contagem de iterações (CONT) é incrementado de 1, e o fluxo é enviado para a instrução com o rótulo (“label”) 100, para novo teste com o novo valor de CONT.

Caso o valor de CONT ultrapasse o de MAX, o fluxo da execução é enviado para a instrução com o rótulo 200, quando o valor atual da soma (SOMA) será impresso.

Para os dados deste código, a soma será 1 + 2 + 3 + 4 = 10.

Durante a quarta iteração, será somado o valor 4 à variável SOMA, CONT será incrementado para 5, o teste de parada (5 > 4) resultará verdadeiro e o fluxo irá para a instrução de impressão, encerrando o ciclo de repetição.

Teste de mesa

Este teste serve para simular a execução de um programa, permitindo acompanhar, para cada instrução executada, a atualização dos valores das variáveis envolvidas e dos testes condicionais realizados pela instrução de parada.

O teste de mesa era muito importante na época do início da programação, para garantir que a gente não perdesse muito tempo nas diversas operações de perfuração dos cartões e espera, por até 2 horas, para sair a listagem indicando os possíveis erros que havia no código.

Com este teste, a gente procurava garantir que nas primeiras submissões do código para execução, ele apresentasse o mínimo de erros de digitação e de lógica.

Além disso, o teste pode ajudar a criar um bom algoritmo em pseudo-linguagem antes de iniciar a codificação. Eu costumo elaborar um esboço de algoritmo antes de iniciar qualquer codificação e fazer um teste de mesa inicial para simular a execução do programa.

Por fim, ele é útil para resolver questões de acompanhamento de códigos em processos de avaliação, como provas e concursos, por exemplo, quando não se tem um computador para testar o código.

A seguir, é mostrado o teste de mesa para o código criado:

Além daquela classificação pela posição da instrução de teste de parada, os comandos de repetição também podem ser divididos em mais 2 tipos;

·        Número de repetições conhecido;

·        Número de repetições desconhecido.

No primeiro caso, quando chegar ao número de repetições especificado, a execução do bloco é encerrada. No segundo, é preciso que haja um valor definido, diferente dos dados de entrada, para que ele seja reconhecido no teste de parada e a execução pare.

No segundo caso, para um programa que lê as notas de alunos de uma turma, é preciso que uma nota diferente dos valores entre 0 e 10 (ou 0 e 100) seja definida como condição de parada (por exemplo, -1, não existente no domínio das notas). No caso de leitura de uma lista de nomes de alunos, o dado da condição de parada poderia ser um nome com string vazio (“”), por exemplo.

3 – Exemplos de comandos de repetição

Considerando algumas das linguagens que eu já programei, vou listar os comandos de repetição mais comuns, antigos e atuais.

COM O TESTE DE PARADA NO INÍCIO DO BLOCO

FOR (em Python)

for i in range(5): # iterações de 0 a 4
 print(i)

 Este comando também é oferecido por outras linguagens de programação: C, C++, C#, Perl, PHP, Java, Javascript, Kotlin, Pascal e BASIC (FOR-NEXT).

WHILE (em Java)

     int i = 0;
     while (i < 5) {
         System.out.println(i);
         i++;
     }

 Note a instrução i++, para atualizar o valor da variável usada no teste de parada!

Este comando também é oferecido por outras linguagens de programação: Python, C, C++, C#, Perl, PHP, Javascript, Kotlin, Pascal e BASIC (WHILE-WEND).

FOREACH (em C#)

     int[ ] array = {1, 2, 3};
     foreach (int num in array) {
         Console.WriteLine(num);
     }

 Este comando também é oferecido por outras linguagens de programação: PHP, e Kotlin.

FOR-OF (em Javascript)

let array = [1, 2, 3];
for (let num of array) {
 console.log(num);
}

 Este comando só é oferecido em Javascript.

DO (em Fortran)

 DO I = 1, 5
     PRINT *, I
 END DO

 Este comando só é oferecido em FORTRAN.

WHILE-WEND (em BASIC)

I = 0
WHILE I < 5
 PRINT I
 I = I + 1
WEND
 

Note a instrução I = I + 1, para atualizar o valor da variável usada no teste de parada!

FOR-NEXT (em BASIC)

FOR I = 0 TO 4
 PRINT I
NEXT I

Note a instrução NEXT I, para atualizar o valor da variável usada no teste de parada!

Estes 2 comandos só são oferecidos em BASIC.

ENHANCED FOR (em Java)

     int[ ] array = {1, 2, 3};
     for (int num : array) {
         System.out.println(num);

 Este comando só é oferecido em Java.

UNTIL (em Perl)

$i = 0;
until ($i == 5) {
 print "$i\n";
 $i++;
}

Note a instrução $i++, para atualizar o valor da variável usada no teste de parada!

Este comando só é oferecido em Perl.

COM O TESTE DE PARADA NO FINAL DO BLOCO

DO-WHILE ( em C )

 i = 0;
 do {
     printf("%d\n", i);
     i++;
 } while (i < 5);

Note a instrução i++, para atualizar o valor da variável usada no teste de parada!

Este comando também é oferecido por outras linguagens de programação: C++, C#, Perl, PHP, Java, Javascript, Kotlin, FORTRAN.

Em C++, ele é Idêntico a C, mas ainda oferece suporte adicional a iteradores para estruturas mais complexas.

REPEAT-UNTIL (em Pascal)

 i:= 0;
 repeat
 writeln(i);
 i:= i + 1;
 until i = 5;

Note a instrução i = i + 1, para atualizar o valor da variável usada no teste de parada!

Este comando só é oferecido em Pascal. Ele é parecido com o UNTIL, do Perl, mas neste do Pascal o teste é realizado no final do bloco.

MAIS ALGUMAS CONSIDERAÇÕES IMPORTANTES:

Delimitadores - Dos exemplos acima, podemos notar que os blocos de comandos múltiplos são delimitados por caracteres que indicam ao compilador quais instruções fazem parte do bloco e serão repetidas.

Algumas vezes, os delimitadores são as palavras-chave inicial e final do comando, como:

·        DO e END DO, em FORTRAN;

·        WHILE e WEND, em BASIC;

·        FOR e NEXT, em BASIC;

·        REPEAT e UNTIL, em Pascal;

·        DO e WHILE, em várias linguagens.

Já outros usam palavras-chave especificadas como delimitadores de blocos nas linguagens:

·        begin e end, em Pascal;

·        { e }, na maioria das linguagens atuais.

Em Python, o início de um bloco de comandos é indicado pelo caractere “dois pontos” ( : ), enquanto as instruções constantes do bloco devem ser, obrigatoriamente, indentadas (com uma tabulação). A primeira instrução com indentação diferente da anterior já pertence a outro bloco de comandos anterior.

·        : e tabulação, em Python.

Condições de parada – os tipos básicos de comandos de repetição, citados anteriormente, possuem as seguintes características, que os diferenciam:  

·        WHILE – O teste é no início do bloco, e a condição é verdadeira em todas as iterações, menos a da iteração final, FALSA, que encerra o loop.

·        DO-WHILE – O teste é no FINAL do bloco, e a condição é verdadeira em todas as iterações, menos a da iteração final, FALSA, que encerra o loop.

·        REPEAT-UNTIL – O teste é no FINAL do bloco, e a condição é falsa em todas as iterações, menos a da iteração final, verdadeira, que encerra o loop.

·        UNTIL - O teste é no início do bloco, e a condição é falsa em todas as iterações, menos a da iteração final, verdadeira, que encerra o loop.

OBS - Inglês básico: WHILE significa enquanto, DO-WHILE significa faça-enquanto, UNTIL significa “Até que” REPEAT-UNTIL significa Repita-“Até que”.

Saída forçada – Os comandos de repetição atuais oferecem formas de interromper as iterações de forma imediata e forçada.

A instrução “Break” interrompe a iteração imediatamente, passando o fluxo para a próxima instrução logo após o bloco de comandos.

Já a instrução “Continue” salta as próximas instruções do bloco de repetição e inicia a iteração com o próximo valor da variável de controle. Por exemplo, veja o código seguinte, na linguagem C:

for (int i = 0; i < 5; i++) {
     if( i == 3) continue;
     printf("%d\n", i);
 }

Neste caso, quando a variável i for igual a 3, a instrução printf será pulada e não imprimirá o valor 3. A iteração continuará com o próximo valor de i (4) e seguirá normalmente até o final, quando i for igual a 5, resultando em condição falsa no teste e o loop se encerrará.

4 – Considerações finais

Este é mais um artigo da série DIRETO AO PONTO, que eu estou escrevendo para a DIO.

Desta vez, eu falei sobre os comandos de repetição, mais um dos comandos de blocos múltiplos.

Eles são usados para agrupar, em uma só estrutura, comandos que são repetidos sequencialmente em um programa, cada vez com novos dados.

As repetições (iterações) são controladas por uma condição de parada, testada em cada iteração. Enquanto esta condição de parada não ocorre, uma nova iteração das instruções é iniciada.

Cada nova iteração deve se basear em um novo valor da variável testada na condição de parada, a fim de evitar que o comando entre em loop infinito. Por isso, nunca devemos esquecer de escrever esta instrução no bloco de um comando de repetição!

Os comandos de repetição podem ser separados em 2 tipos básicos, de acordo com o momento em que é realizado o teste de parada, no início ou no final do bloco.

Desde as primeiras linguagens de programação, este tipo de comando já existia e as linguagens oferecem diferentes maneiras de implementá-lo.

No próximo artigo, eu vou começar a falar sobre mais um bloco de comandos múltiplos, as funções e procedimentos.

5 – Referências

Praticamente todo o conteúdo deste artigo foi tirado do que eu aprendi (e me lembro) sobre o assunto desde o início da minha carreira como programador, desde os anos 80 até agora.

Para a elaboração dos códigos com os detalhes dos comandos oferecidos pelas diversas linguagens de programação usadas aqui, eu consultei as ferramentas ChatGPT e Copilot.

Artigos desta série: ( < ) Anterior | Índice | Seguinte ( > )