8.1. Introdução
[C] Normalmente, a execução
dos comandos num programa é feita na ordem em que os comandos são
escritos: de cima para baixo, linha por linha, de acordo com a estrutura
seqüencial. Entretanto você pode usar comandos para transferir
o controle de fluxo para outra parte da mesma unidade de programa ou para
outra unidade de programa.
[C] O controle pode ser transferido somente
para um comando executável.
[D] Por vezes, um comando pode ser identificado
por um "número de comando", consistindo de um número inteiro,
escrito antes do comando, no início da linha. Cada número
de comando deve ser único dentro da unidade de programa. Eles servem
principalmente para a especificação de formatos de entrada
e/ou saída de dados. Evita-se hoje o uso antigo do número
de comando, que servia de referência para uma transferência
de controle de fluxo. Isto favorece a criação de códigos
de programa "espaguete", sendo que o controle de fluxo pode ser mudado
de maneira absurda, dificultando e inviabilizando a manutenção
dos programas.
8.2. Estruturas de Controle
[C] As estruturas básicas de controle
são:
8.3. Comandos GO TO
[CF] Os comandos GO TO transferem o controle de fluxo para um comando executável na mesma unidade de programa. Os três tipos de GO TO são:
8.3.1. Comando GO
TO incondicional
[CF] O comando GO TO incondicional transfere
o controle para o comando identificado pelo número de comando especificado
no GO TO.
[CF] A forma geral do comando GO TO incondicional é:
go to n
sendo que "n" é um número
de comando executável.
8.4. Comandos IF
[CF] Os comandos IF transferem o controle do fluxo ou executam outro comando (ou um bloco de comandos) dependendo do resultado verdadeiro ou falso de uma expressão lógica contida no particular comando IF. Os três tipos de comandos IF são:
[CF] Os comandos ELSE, ELSE IF e END
IF são também apresentados nesta seção, pois
eles são usados somente em conjunto com um comando IF bloco.
8.4.1. Comando IF lógico
[CF] O comando IF lógico calcula
uma expressão lógica/relacional e executa ou ignora um comando
executável contido no próprio IF, dependendo do valor (falso
ou verdadeiro) dessa expressão.
[CF] A forma geral do comando IF lógico é:
if (e) c
sendo que:
- "e" é uma expressão lógica
ou relacional.
- "c" é o comando que será
executado caso a expressão seja verdade; "c" não pode ser
um comando DO.
[E] Vejamos como fica o fluxo do programa quando este chega a estas três linhas:
x=a-b
if(a.eq.b) x=a+b
y=x**2
Observe que nas últimas 2 linhas
temos três comandos:
1) if(a.eq.b)
2) x=a+b
3) y=x**2
Então:
a) Se de fato a=b, teremos a seguinte
ordem de execução: 1 >> 2 >> 3.
b) Se, por outro lado, a é diferente
de b, teremos a ordem de execução: 1 >> 3.
8.4.2. Comandos IF bloco
[CF] O comando IF bloco permite a execução
de um determinado bloco de comandos, dependendo do valor da(s) expressões
lógica(s)/relacional(is) nele contido.
[CF] A forma geral do comando IF bloco
é:
if (e1) then
bloco1
else if (e2) then
bloco2
else if (e3) then
bloco3
...
else
bloco n
endif
sendo que e1, e2,e3, ... são expressões
lógicas/relacionais. Deve ficar claro que somente um dos blocos
de comandos será executado.
[C] O menor IF bloco é a estrutura:
if (e) then
bloco
endif
Vemos que os comandos ELSE IF e ELSE são
opcionais.
[CF] O comando IF THEN permite a execução
condicional de um bloco de comandos executáveis. É obrigatório
usar em conjunção o comando ENDIF para fechar o comando.
[CF] A forma geral do comando IF THEN é:
if (e) then
sendo que "e" é uma expressão
lógica/relacional (portanto produzindo um resultado verdadeiro ou
falso).
[C] Se a expressão "e" for verdadeira,
a execução passa para o próximo comando executável
e daí para o comando ENDIF. Se for falsa, o controle é transferido
para o próximo comando: ELSE IF THEN, ELSE ou ENDIF.
[CF] O comando ELSE fornece uma rota alternativa para um comando IF THEN ou ELSE IF THEN. Sua forma geral é simplesmente:
else
[CF] O comando ELSE IF THEN combina as
funções dos comandos ELSE e IF THEN, pois fornece uma rota
alternativa e torna possível uma estrutura IF bloco com mais de
uma alternativa.
[CF] A forma geral do comando ELSE IF THEN é:
else if (e) then
sendo que "e" é uma expressão
lógica/relacional.
[C] Se a expressão for verdadeira,
o controle passa para o próximo comando executável e daí
para o comando ENDIF. Se for falsa, passa para o próximo comando
ELSE IF THEN, ELSE ou ENDIF.
[CF] O comando ENDIF ou END IF finaliza uma estrutura IF bloco. Sua forma geral é simplesmente:
end if
[E] Exemplo:
...
print *,'Digite a nota
do aluno: '
read *,nota
if(nota>=5.0) then
print *,'O aluno foi aprovado.'
elseif(nota>=3.5) then
print *,'O aluno foi reprovado mas podera cursar o RE.'
else
print *,'O aluno foi reprovado e nao podera cursar o RE.'
endif
?
8.4.3. Estruturas de IF bloco encaixados
[C] Um bloco de comandos executáveis
dentro de um comando IF bloco pode conter outra estrutura IF bloco. E isto
pode se repetir indefinidamente.
...
print *,'Digite a nota
do aluno: '
read *,nota
if(nota>=5.0) then
if(nota>=9.5) then
print *,'O aluno foi aprovado com louvor.'
elseif(nota>=8.0) then
print *,'O aluno foi aprovado com distincao.'
else
print *,'O aluno foi aprovado.'
endif
elseif(nota>=3.5) then
print *,'O aluno foi reprovado mas podera cursar o RE.'
else
print *,'O aluno foi reprovado e nao podera cursar o RE.'
endif
?
8.5. Comando DO
[CF] O comando DO é um comando de
controle que permite que um bloco de comandos seja repetitivamente executado.
O número de execuções depende da variável de
controle.
[CF] A forma geral do comando DO é:
do v = vi , vf [, incr]
sendo que:
- "v" é a variável do controle
do laço DO.
- "vi" é o valor inicial de v.
- "vf" é o valor final ou máximo
de v.
- "incr" é o incremento de v. Se
for omitido, é suposto como de valor 1.
[CF] O comando ENDDO ou END DO finaliza uma estrutura DO. Sua forma geral é simplesmente:
enddo
[E] Exemplo:
do i=0,100,5
bloco de comandos
enddo
[C] Existem duas estruturas DO:
1) A estrutura DO - END DO (repeat loop) repete um bloco de comandos condicionado ao valor de uma variável de controle que deve variar de modo fixo e pré-determinado:
do v=vi,vf,incr
bloco de comandos
end do
2) A estrutura DO WHILE - END DO (while loop) executa o laço DO enquanto uma expressão lógica/relacional for verdadeira:
do while (var.ge.0)
bloco de comandos
end do
[CF] O comando DO implícito é uma terceira forma do comando DO e somente pode ser usando em comandos de entrada ou saída de dados.
[E] Exemplos de uso do comando DO implícito:
print *,(var(i),i=1,10,1)
print *,(var(i,j),j=10,20,2)
read(1,100)(var(i),i=2,8,2)
write((3,200)(var(i,j),j=1,5,1)
8.5.1. Laços de DO encaixados
[C] É possível encaixar dois ou mais comandos DO.
[C] Para as estruturas DO encaixadas, o
primeiro comando END DO após o comando DO, fecha o laço.
8.6. Comando EXIT
[CF] O comando EXIT termina abruptamente um laço DO, direcionando o fluxo do programa para a primeira linha de comando após o ENDDO daquele respectivo comando DO envolvido.
8.7. Comando CYCLE
[CF] O comando CYCLE reinicia abruptamente um laço DO, direcionando o fluxo do programa para a linha do comando DO dentro do qual ele está inserido.
8.8. Comando CONTINUE
[CF] O comando CONTINUE é um comando executável que somente passa o controle para o próximo comando executável. A forma geral é:
continue
8.9. Comando STOP
[CF] O comando STOP termina a execução
do programa. Apesar de sua localização dentro do programa
em geral ser a penúltima linha de comando, ele pode ser colocado
em qualquer posição dentro do programa.
[CF] A forma geral do comando STOP é:
stop [varcar]
sendo que "varcar" é uma variável
caracter que será exibida na saída padrão (em geral,
a tela do monitor do operador).
8.10. Comando END
[CF] O comando END indica o final de uma unidade de programa para o compilador. Sua forma geral é:
end
e deve obrigatoriamente ser colocado na
última linha do programa.
8.11. Comando SELECT CASE
[C] A estrutura SELECT CASE permite a execução de apenas uma entre muitas opções possíveis.
[CF] A estrutura SELECT CASE possui a seguinte forma:
select case (var)
case (um_valor_de_var)
bloco de comandos 1
case (outro_valor_de_var)
bloco de comandos 2
case (outro_ainda_valor_de_var)
bloco de comandos 3
...
end select
[E] Exemplo:
...
print *,'Digite um
numero de 1 a 10: '
read *,nu
select case (nu)
case (1:4)
print *,'A opcao foi um numero no intervalo [1,4]'
case (5)
print *,'A opcao foi pelo numero 5'
case (6:10)
print *,'A opcao foi um numero no intervalo [6,10]'
end select
...