Existem situações em que um bloco de código necessita ser executado mais de uma vez. Como sabemos, emm geral, as instruções são executadas sequencialmente: a primeira instrução em uma função é executada primeira, seguida pela segunda e assim por diante.

As linguagens de programação contam com várias estruturas de repetição e controle que permitem execuções por caminhos mais complexos do que esta estrutura linear e direta.

Uma instrução de repetição (laço), por exemplo, permite a execução de um grupo de instruções múltiplas vezes.

Veja a seguir a forma geral de uma instrução de repetição generalizada para a maioria das linguagens de programação:

Figura 01 – Diagrama de bloco de estrutura de repetição usando estrutura condicional condicional if

O Fortran permite as seguintes construções para as instruções das estruturas de repetição:

Tipo de Laço	Descrição
do	Esta forma permite que uma instrução ou uma série de instruções possam ser manipuladas interativamente um numero finito de vezes.
do while	Esta forma permite a repetição de um grupo de instruções enquanto uma condição seja verdadeira. Ela testa a condição antes do corpo do loaço. nested loops
repetição aninhada	É permitido a a construção de uma ou mais estruturas de repetição dentro da outra.

Instruções de controle do laço

As instruções de controle de laço são responsáveis por alterar a execução de sua sequência normal. Quando a execução deixa o escopo, todos os objetos automáticos que foram criados naquele escopo são destruídos.

Fortran suporta as seguintes instruções de controle de laço.

Instrução de controle	Descrição
exit	Se a isntrução exit for executada, o laço termina e a execução do programa continua na proxima instrução após o fim do laço end do.
cycle	Se a instrução cycle for exectuda, o programa salta para a próxima iteração.
stop	Se o comando stop for executado, o programa é terminado.

Vamos ver a seguir, em detalhes, todas essas estruturas de repetição e controle e alguns exemplos.

Instrução Do

Essa instrução (comando) permite que uma instrução ou uma série de instruções possam ser manipuladas interativamente um numero finito de vezes.

NOTA O teste da condição é feito antes da execução do corpo laço.

PENSE Será esta uma boa afirmação?

Sintaxe

A forma geral do comando de laço DO é:

do var = inicio, fim [,passo]    
   ! comando(s)
   ...
end do

em que,

• var é a variável contador do laço
• início é o valor inicial
• fim é o valor final
• passo é o incremento, opcional e se omisso então o valor da variável será incrementado de uma unidade

Diagrama de Blocos (fluxograma)

Descrição genérica do fluxo de execução das estruturas de repetição:

• O passo inicial init é executado primeiro, e uma única vez. Este passo permite declarar e inicializar as variáveis de controle do laço. No caso mostrado no bloco Sintaxe a variável var é inicializada com o valor inicio.
• Na sequência, a condição é avaliada. Se o resultado for verdadeiro .true., o bloco de código seguinte no corpo do laço é executado. Se a resposta for falsa .false., as instruções no corpo do laço não serão executadas o controle do fluxo salta para a próxima instrução na sequência fora do laço. No caso mostrado no bloco Sintaxe essa condição é alcançada quando a varável var alcançar o valor fim.
• Depois que as instruções do corpo do laço forem executadas, o controle do fluxo salta para a instrução de incremento (Esta instrução permite atualizar a variável de controle do laço var ).
• A condição de controle é testada novamente. Se a resposta for verdadeira, a estrutura do laço se repete (corpo do laço, incremento, e teste da condição). Somente quando o resultado do teste da condição for falso é que o laço termina.

Figura 02 – Diagrama de Bloco estrutura de repetição do

NOTA Todas as variáveis usadas na estrutura de repetição devem ser do tipo inteiras. Esta regra se tornou padrão a partir da versão Fortran 90

Por exemplo:

! Calcula fatoriais
do n = 1, 10
   nfact = nfact * n  
   ! Mostrando o valor de n e seu fatorial
   print*,  n, " ", nfact   
end do

Exemplo 01:

Este exemplo mostra no display a sequência dos números 11 até 20:

program printNum 
implicit none  

   ! define variáveis
   integer :: n

   do n = 11, 20     
      ! mostrando o valor de n 
      print*,  n 
   end do 

end program printNum

Após o código ser compilado e executado, produzirá o seguinte resultado:

    11
    12
    13
    14
    15
    16
    17
    18
    19
    20

Exemplo 2

Este programa calcula o Fatorial da sequência de números de 1 até 10:

program factorial  
implicit none  

   ! define variaveis
   integer :: nfact = 1   
   integer :: n  

   ! compute factorials   
   do n = 1, 10      
      nfact = nfact * n 
      ! mostrando valores de n e seu fatorial
      print*,  n, " ", nfact   
   end do 

end program factorial

Após o código ser compilado e executado, produzirá o seguinte resultado:

1             1
2             2
3             6
4            24
5           120
6           720
7          5040
8         40320
9        362880
10       3628800

Instrução do while

Esta instrução repete uma instrução ou conjunto de instruções enquanto uma dada condição `expressao_logica` for verdadeira.

NOTA O teste da condição é feito antes da execução do corpo laço.

Sintaxe

do while (expressão_lógica) 
   instruções
end do

Figura 03 – Diagrama de Bloco estrutura de repetição do while

Exemplo 01

program factorial  
implicit none  

   ! define variaveis
   integer :: nfact = 1   
   integer :: n = 1 

   ! calcula fatoriais   
   do while (n <= 10)       
      nfact = nfact * n           
      print*,  n, " ", nfact  
   n = n + 1
   end do 
end program factorial  

Após o código ser compilado e executado, produzirá o seguinte resultado:

           1             1
           2             2
           3             6
           4            24
           5           120
           6           720
           7          5040
           8         40320
           9        362880
          10       3628800

Laços aninhados

Pode se usar uma ou mais instrução de repetição (laço) dentro de outra instrução de repetição, sendo possível a partir da versãoFortran 90, nomear cada uma das estruturas de repetição.

Sintaxe

iloop: do i = 1, 3
   print*, "i: ", i

   jloop: do j = 1, 3         
      print*, "j: ", j         

      kloop: do k = 1, 3
         print*, "k: ", k

      end do kloop
   end do jloop  
end do iloop

Exemplo

program nestedLoop 
implicit none

   integer:: i, j, k

   iloop: do i = 1, 3      
      jloop: do j = 1, 3         
         kloop: do k = 1, 3              

            print*, "(i, j, k): ", i, j, k               

         end do kloop       
      end do jloop
   end do iloop

end program nestedLoop  

Após o código ser compilado e executado, produzirá o seguinte resultado:

(i, j, k): 1  1  1
(i, j, k): 1  1  2
(i, j, k): 1  1  3
(i, j, k): 1  2  1
(i, j, k): 1  2  2
(i, j, k): 1  2  3
(i, j, k): 1  3  1
(i, j, k): 1  3  2
(i, j, k): 1  3  3
(i, j, k): 2  1  1
(i, j, k): 2  1  2
(i, j, k): 2  1  3
(i, j, k): 2  2  1
(i, j, k): 2  2  2
(i, j, k): 2  2  3
(i, j, k): 2  3  1
(i, j, k): 2  3  2
(i, j, k): 2  3  3
(i, j, k): 3  1  1
(i, j, k): 3  1  2
(i, j, k): 3  1  3
(i, j, k): 3  2  1
(i, j, k): 3  2  2

Instrução exit

A instrução exit termina o laço ou instrução select case, transferindo a execução para o laço ou select imediatamente seguinte.

Figura 04 – Diagrama de Bloco da Instrução de controle exit

Example

    program nestedLoop 
    implicit none

    integer:: i, j, k
       iloop: do i = 1, 3      
          jloop: do j = 1, 3         
             kloop: do k = 1, 3    

             print*, "(i, j, k): ", i, j, k               

             if (k==2) then
                exit jloop 
             end if

             end do kloop       
          end do jloop  
       end do iloop 

    end program nestedLoop

Após o código ser compilado e executado, produzirá o seguinte resultado:

(i, j, k): 1  1  1
(i, j, k): 1  1  2
(i, j, k): 2  1  1
(i, j, k): 2  1  2
(i, j, k): 3  1  1
(i, j, k): 3  1  2

Instrução Cycle

A instrução cycle causa um salto para o final do corpo do laço, e, imediatamente reinicia a sua condição prévia à iteração anterior.

Exemplo

program cycle_example     
implicit none      

   integer :: i     

   do i = 1, 20          

      if (i == 5) then 
         cycle          
      end if         

   print*, i      
   end do  

end program cycle_example

Após o código ser compilado e executado, produzirá o seguinte resultado:

1
2
3
4
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

NOTA Perceba a ausência do valor quando o valor de i for 5.

Instrução Stop

Se for necessário que a execução do programa pare, deve-se inserir no código a instrução stop.

Por exemplo:

program stop_example     
implicit none
voide
namespace
integer :: i     

  do i = 1, 20          

     if (i == 5) then 
         stop          
     end if         

     print *, i      
  end do  

end program stop_example

Após o código ser compilado e executado, produzirá o seguinte resultado:

1
2
3
4

 Desafio

1. Escreva um código fonte em Fortran conforme indicado pela figura a seguir:
   
   Figura: Brian D Hahn – Fortran 90 for Scientists and Engineers
   Nível: Médio

 Exercícios de fixação

1. Escreva um programa para ler valores inteiros. O programa termina quando o valor 0 (zero) for lido. Ao final, o programa deve imprimir quantos números lidos são negativos e quantos são positivos. Nível: Médio
2. Escreva um programa para ler o raio e a cor de cada esfera em um conjunto de 10 amostras. O programa deve imprimir a média da área superficial das esferas e a cor da esfera que tiver a maior área. Neste programa, uma estrutura de repetição contável deve ser utilizada. Nível: Médio

---

Leitura Extra

---

---

IDPFPG-1806