Info: Última Atualização 08-07-2021

---

As estruturas de decisão (também conhecidas como Estruturas Condicionais ou Blocos condicionais) exigem que o programador especifique uma ou mais condição a ser testada pelo programa, juntamente com uma instrução (ou conjunto) a ser executada se o resultado do teste for verdadeiro, e, opcionalmente, outra instrução ou conjunto de instruções caso o resultado do teste seja falso.

A figura a seguir mostra a forma geral do diagrama de blocos típico de uma estrutura de decisão encontrada na maioria das linguagens de programação:

Figura 01 – Estrutura Condicional

Em Fortran se pode construir as estruturas de tomada de decisões das seguintes maneiras.

Instrução	Descrição
if... then	Consiste de uma expressão lógica seguida por uma ou mais instruções.
if... then...else	A instrução if...then pode ser seguida por uma instrução else opcional que será executada quando o resultado da espressão lógica for falsa
if...else if...else	A instrução if pode ser seguida, opcionalmente, por uma ou mais instruções else if. Quando o resultado da expressão lógica na instrução if é falso, imediamente a instrução else if seguinte é executada. Quando esta instrução else if também for falsa, se houver uma próxima instrução else if ela será executada e assim por diante.
if aninhado	É permitido usar uma instrução if ou else if dentro de outra instrução if ou else if.
select case	A instrução select case permite uma variável ser comparada com uma lista de possíveis valores.
select caseaninhado	É permitido usar uma instrução select case dentro de outra instrução select case.

A seguir vamos estudar cada uma das possíveis construção das estruturas condicionais descritas.

if…then

Consiste de uma expressão lógica seguida por uma ou mais instruções e terminada pela instrução end if.
Sintaxe Sintaxe básica para a instrução if...then:

if (expressao_lógica) then      
   instruções  
end if

além disso, é possível nomear o bloco, a sintaxe do bloco nomeado é a seguinte:

[nome:] if (expressao_lógica) then      
   ! várias instruções
   . . .
end if [nome]

Se o resultado da expressão lógica for verdadeiro, então o bloco de código (instruções) dentro da instrução if...then será executado. Se o resultado da expressão lógica for verdadeiro, então o primeiro conjunto de instruções após a instrução end if serão executados.

Na Figura 02 é mostrado o diagrama de blocos com a lógica desta construção:

Figura 02 – Diagrama de Bloco if then.

Veremos a seguir alguns exemplos para ilustrar esta forma de construção.

Exemplo 1

program ifProg
implicit none

! local variable declaration
integer :: a = 10

! check the logical condition using if statement
if (a < 20 ) then
    !if condition is true then print the following
    print*, "a é menor que 20"
end if

print*, "o valor de a é ", a

end program ifProg

Quando esse código fonte for compilado e executado, produzirá o seguinte resultado:

a é menor que 20
o valor de a é 10

Exemplo 2 O próximo exemplo mostra um código com bloco if nomeado:

program markGradeA
implicit none

real :: marks

! assign marks
marks = 90.4

! use an if statement to give grade
gr: if (marks > 90.0) then
        print *, " Grade A"
    end if gr

end program markGradeA

Quando esse código fonte for compilado e executado, produzirá o seguinte resultado:

Grade A 

if…then…else

A instrução if...then pode ser seguida por uma instrução else opcional que será executada quando o resultado da espressão lógica ( expressão_lógica ) for falsa.

Syntaxe: A sintaxe básica para a instrução if...then...else:

if (expressão_lógica) then      
   instruções
else
   outras_instruções
end if

Também é possível nomear bloco desse if, a sintaxe para a instrução if...then...else é:

[nome:] if (expressão_lógica) then      
   ! várias instruções         
   . . . 
   else
   !outras várias instruções
   . . . 
end if [nome]

Se o resultado da expressão lógica for verdadeira , então o bloco de código com as instruções dentro do if...then será executado, caso contrário, o bloco de código com as instruções dentro do bloco elseserá executado.

Figura 03 – Diagrama de Bloco if...then...else.

Veremos a seguir alguns exemplos para ilustrar esta forma de construção.

Exemplo 01

program ifElseProg
implicit none
! local variable declaration
integer :: a = 100

! check the logical condition using if statement
if (a < 20 ) then

! if condition is true then print the following
print*, “a é menor que 20”
else
print*, “a não é menor que 20”
end if

print*, “o valor de a é “, a

end program ifElseProg

Quando esse código fonte for compilado e executado, produzirá o seguinte resultado:

a não é menor que 20
o valor de a é 100

if…else if…else

A instrução if pode ser seguida, opcionalmente, por uma ou mais instruções else if. Quando o resultado da expressão lógica na instrução if é falso, imediamente a instrução else if seguinte é executada. Quando esta instrução else if também for falsa, se houver uma próxima instrução else if ela será executada e assim por diante.

Um else opcional pode ser declarado no final do bloco e as instruções seguintes a ele serão executadas caso nenhuma das expressões logicas anteriores forem satisfeitas (no caso verdadeiras)

Observar que ao tratar de estruturas condicionais, a expressão lógica em questão será validada e o destino do “fluxo” do programa depende da adequação da expressão lógica à lógica que o programador estabeleceu.

• Todas as instruções else if e else são opcionais.
• A instrução else if pode ser usado uma ou mais vezes
• A instrução else deve ser declarada apenas uma vez e sempre no final da estrutura condicional.

Sintaxe: A sintaxe da instrução if...else if...else é:

[name:] 
if (logical expression 1) then 
   ! block 1   
else if (logical expression 2) then       
   ! block 2   
else if (logical expression 3) then       
   ! block 3  
else       
   ! block 4   
end if [name]

Exemplo 1

program ifElseIfElseProg
implicit none
! local variable declaration
integer :: a = 100
! check the logical condition using if statement
if( a == 10 ) then
! if condition is true then print the following
print*, "Value of a is 10"
else if( a == 20 ) then
! if else if condition is true
print*, "Value of a is 20"
else if( a == 30 ) then
! if else if condition is true
print*, "Value of a is 30"
else
! if none of the conditions is true
print*, "None of the values is matching"
end if
print*, "exact value of a is ", a
end program ifElseIfElseProg

print*, “exact value of a is “, a

end program ifElseIfElseProg

Quando esse código fonte for compilado e executado, produzirá o seguinte resultado:

None of the values is matching
exact value of a is 100

if aninhada

É permitido usar uma instrução if ou else if dentro de outra instrução if ou else if.
Sintaxe: A sintaxe para a instrução if aninhada é:

if ( expressão_lógica_1 ) then
   !Executa instruções quando a expressão lógica 1 for verdadeira 
   ...
   if( expressão_lógica_2 ) then 
   !Executa instruções quando a expressão lógica 2 for verdadeira 
   ...
   end if
end if

Exemplo 1.

program nestedIfProg
implicit none
! local variable declaration
integer :: a = 100, b= 200
! check the logical condition using if statement
if( a == 100 ) then
! if condition is true then check the following
if( b == 200 ) then
! if inner if condition is true
print*, "Value of a is 100 and b is 200"
end if
end if
print*, "exact value of a is ", a
print*, "exact value of b is ", b
end program nestedIfProg

Quando esse código fonte for compilado e executado, produzirá o seguinte resultado:

Value of a is 100 and b is 200
exact value of a is 100
exact value of b is 200

select case

A instrução select case permite uma variável ser comparada com uma lista de possíveis valores.

Sintaxe: A sintaxe para a instrução select case é:

[name:] select case (expression) 
   case (selector1)          
   ! some statements          
   ... case (selector2)           
   ! other statements           
   ...       
   case default          
   ! more statements          
   ...   
end select [name]

A instrução de seleção select case exige algumas regras:

• A expressão lógica utilizada em uma instrução SELECT pode ser lógica, caractere ou inteiro (mas não real);
• Você pode ter qualquer número de instruções case dentro de um select. Cada case é seguido pelo valor a ser comparado e pode ser uma expressão do tipo lógico, caractere, ou inteiro (mas não real) determinando quais comandos serão executados;
• A expressão ou constante para o case, deve ser do mesmo tipo de dados como a variável no select, e deve ser uma constante ou uma literal (caractere);
• Quando a variável a ser selecionado, é igual a um caso, as seguintes afirmações nesse caso irá executar até a próxima instrução case é atingido.
• O bloco case default é executado se a expressão no case selectnão corresponder a nenhum dos seletores.

Figura 04 – Diagrama de Blocos select case.

Vamos explorar alguns exemplos.

Exemplo 1

program selectCaseProg
implicit none

! local variable declaration
character :: grade = ‘B’

select case (grade)

case (‘A’)
print*, “Excellent!”

case (‘B’)

case (‘C’)
print*, “Well done”

case (‘D’)
print*, “You passed”

case (‘F’)
print*, “Better try again”

case default
print*, “Invalid grade”

end select

print*, “Your grade is “, grade

end program selectCaseProg

Quando esse código fonte for compilado e executado, produzirá o seguinte resultado:

Your grade is B

Especificando uma faixa de valores para o seletor

É possível especificar uma faixa de valores para o seletor, especificando um valor mínimo e um valor máximo separados pelo caractere :, como mostrado a seguir:

case (valor_mínimo:valor_máximo) 

O próximo exemplo demonstra seu uso:
Exemplo 2

program selectCaseProg
implicit none

! local variable declaration
integer :: marks = 78

select case (marks)

case (91:100)
print*, “Excellent!”

case (81:90)
print*, “Very good!”

case (71:80)
print*, “Well done!”

case (61:70)
print*, “Not bad!”

case (41:60)
print*, “You passed!”

case (:40)
print*, “Better try again!”

case default
print*, “Invalid marks”

end select
print*, “Your marks is “, marks

end program selectCaseProg

Quando esse código fonte for compilado e executado, produzirá o seguinte resultado:

Well done!
Your marks is 78

select case aninhada

É permitido usar uma instrução select case dentro de outra instrução select case.

Sintaxe A sintaxe para a instrução select case aninhada é:

select case(a)

case (100)
print*, “This is part of outer switch”, a

select case(b)
case (200)
print*, “This is part of inner switch”, a

end select

end select

Exemplo 1

program nestedSelectCase
! local variable definition
integer :: a = 100
integer :: b = 200

select case(a)
case (100)
print*, “This is part of outer switch”, a

select case(b)
case (200)
print*, “This is part of inner switch”, a
end select

end select

print*, “Exact value of a is : “, a
print*, “Exact value of b is : “, b

end program nestedSelectCase

Quando esse código fonte for compilado e executado, produzirá o seguinte resultado:

This is part of outer switch 100
This is part of inner switch 100
Exact value of a is : 100
Exact value of b is : 200

Desafio

1. Faça um programa em Fortran que leia um valor para um comprimento de onda e indique em qual faixa do espectro eletromagnético ela está. Baseado nesta informação, calcule e mostre a frequência e também a energia dessa radiação.Dica: Use as informações disponíveis em https://pt.wikipedia.org/wiki/Espectro_visivel. Nível: Fácil

---

IDPFPG-1638