# 3.0 Estrutura condicional dos algoritmos

_Fonte: Adaptado de https://devschannel.com/_

***

1. [3.0 Estrutura condicional dos algoritmos](broken-reference)
2. [Estruturas de seleção](broken-reference)
   1. [Estrutura se](broken-reference)
   2. [Estrutura senao](broken-reference)
   3. [Fluxograma](broken-reference)
   4. [Estrutura senao se](broken-reference)
3. [Aninhamento](broken-reference)
   1. [Se vs senao se](broken-reference)
4. [​​​​​​​Estrutura escolha-caso](broken-reference)
   1. [O que você aprendeu:](broken-reference)
5. [Material Extra](broken-reference)

### Estruturas de seleção <a href="#estruturas-de-selecao" id="estruturas-de-selecao"></a>

<figure><img src="https://2486316049-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FuJ6tEYpZRgjLhQMAmb1o%2Fuploads%2FEWSTd4kb4dwREyYksMhs%2Fimage.png?alt=media&#x26;token=d686c152-b6e7-433c-86a1-6f7074dc3b78" alt=""><figcaption></figcaption></figure>

Essas Estruturas de Controle também são conhecidas como  Estruturas de Seleção compondo basicamente o conjunto (SE, SE-ENTÃO, SE-ENTÃO-SENÃO e CASO). Estudemos cada uma delas em detalhes.

#### Estrutura se <a href="#estrutura-se" id="estrutura-se"></a>

Vamos começar com uma estrutura bem simples: a estrutura se, que é o **if** das linguagens de programação.

```
inteiro x = 4
se (x == 4) {
    escreva("x é igual a 4")
}
```

Essa é uma estrutura de seleção muito simples. Ela simplesmente recebe uma condição entre parênteses, e se ela for verdadeira, o código que está dentro das chaves é executado. A sintaxe dela no Portugol é bem parecida com a sintaxe usada pelas linguagens de programação.

Perceba que eu utilizei **`==`** para verificar se `x` é igual a **4**. Esse é um operador de comparação e ele checa se o operando da esquerda é igual ao operando da direita.

Observe que eu digitei um **Tab** no pseudocódigo que está dentro da estrutura de controle. Isso que eu fiz se chama indentação. Ela mostra a hierarquia dos componentes do algoritmo. No caso, ela deixa mais claro que a instrução **`escreva()`** pertence ao se.

#### Estrutura senao <a href="#estrutura-senao" id="estrutura-senao"></a>

Ainda no exemplo anterior, o que faríamos se quiséssemos mostrar uma mensagem caso a variável x não fosse igual a 4? Para isso, existe uma estrutura de controle chamada **senao**. É o **else** das linguagens de programação. Ela deve ser colocada imediatamente depois de um se ou de um **senao** se, que você vai ver daqui a pouco. Veja como ficaria o código com o senao:

```
inteiro x = 4
se (x == 4) {
    escreva("x é igual a 4")
}
senao {
    escreva("x é diferente de 4")
}
```

Veja que a estrutura dela é parecida com o se. A diferença é que o senao não tem nenhuma condição para ser testada. Ele é executado somente quando o se não é executado. Altere o valor de x para 3 para que o senao seja executado.

#### Fluxograma <a href="#fluxograma" id="fluxograma"></a>

Mostrei como as estruturas de decisão **se** e **senao** podem ser representadas em pseudocódigo. Agora, vou mostrar como representá-las em fluxogramas. Se você não viu o [tutorial de fluxogramas](https://portalfisica.com/fsc1189/2-0-estrutura-logica-dos-algoritmos#fluxograms), recomendo fortemente que você veja, já que só vou explicar os elementos novos.

Veja como ficaria a estrutura de controle se representada em um fluxograma:

<figure><img src="https://2486316049-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FuJ6tEYpZRgjLhQMAmb1o%2Fuploads%2FklaS7Z1XQRjwqqg9iu7a%2Fimage.png?alt=media&#x26;token=8ed46350-fddd-4bb3-9438-d9747e27093d" alt=""><figcaption></figcaption></figure>

O losango é usado para expressar a condição da estrutura. Ele sempre deve ter duas ramificações, mesmo que não seja feito nada em uma delas. Para maior clareza, adiciona-se um _Sim_ e um _Não_ a cada ramificação. O losango é um elemento da aba Fluxograma:

<figure><img src="https://2486316049-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FuJ6tEYpZRgjLhQMAmb1o%2Fuploads%2FHvYHcCfP2C8I2CyFiOid%2Fimage.png?alt=media&#x26;token=751d00d0-652e-4d97-b16e-137933ca6f50" alt=""><figcaption></figcaption></figure>

As linhas das ramificações foram criadas usando os retângulos parciais que contém os lados superior e esquerdo, e inferior e direito. Eles estão na aba Básico:

<figure><img src="https://2486316049-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FuJ6tEYpZRgjLhQMAmb1o%2Fuploads%2F9JRib3haiwE4Lfick5BQ%2Fimage.png?alt=media&#x26;token=c2e31451-aeed-4194-890f-b2afd869a040" alt=""><figcaption></figcaption></figure>

Por fim, a linha é um elemento da aba Geral:

<figure><img src="https://2486316049-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FuJ6tEYpZRgjLhQMAmb1o%2Fuploads%2FJTqZX4sluDYauJDJUBDf%2Fimage.png?alt=media&#x26;token=04727db5-0474-4534-9ac1-4de970b1b34e" alt=""><figcaption></figcaption></figure>

O algoritmo que contém a estrutura **senao** é praticamente igual ao anterior. A diferença é que ele contém um output na ramificação do **Não**:

<figure><img src="https://2486316049-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FuJ6tEYpZRgjLhQMAmb1o%2Fuploads%2FlQlgRm8UK277BdU1YNNX%2Fimage.png?alt=media&#x26;token=c77ad8ae-ebe5-4dda-ae2e-ff24ee6b2a56" alt=""><figcaption></figcaption></figure>

#### Estrutura senao se <a href="#estrutura-senao-se" id="estrutura-senao-se"></a>

Essa estrutura precisa vir imediatamente após um **se** ou um **senao se**. Ela é executada quando a estrutura anterior não tem o seu código executado. Até esse ponto ela é igual ao **senao**. A diferença é que nem sempre o **senao se** será executado, porque ele tem uma condição. Se ela for verdadeira, ele é executado. Nesse ponto, ele é igual ao **se**. Então, podemos dizer que essa estrutura pega um pouco das duas estruturas. Inclusive, o nome dela indica isso.

Vamos pensar em um algoritmo que retorna a classificação do IMC (razão Peso x Altura) de acordo com o valor dele:

```
real imc
leia(imc)
se (imc < 18.5) {
    escreva("Abaixo do peso")
}
senao se (imc < 25) {
    escreva("Peso normal")
}
senao se (imc < 30) {
    escreva("Sobrepeso")
}
senao {
    escreva("Obesidade")
}
```

A classificação real é um pouco mais complexa, mas eu simplifiquei para facilitar. Execute o programa algumas vezes usando valores diferentes e veja os resultados. Perceba que eu usei um operador de comparação novo: o <. Ele faz exatamente o que você pensou: verifica se o primeiro operando é menor do que o segundo. Conforme visto em **operadores de comparação (fazer link interno)**.

### Aninhamento <a href="#aninhamento" id="aninhamento"></a>

Vamos imaginar que eu queira fazer um algoritmo que verifique o sexo e a altura de uma pessoa e exiba uma mensagem dizendo Baixo (a) ou Alto (a). Uma das formas de escrevê-lo é essa:

```
logico sexo
real altura
leia(sexo)
leia(altura)
se (sexo == verdadeiro e altura < 1.62) {
    escreva("Baixa")
}
senao se (sexo == verdadeiro e altura >= 1.62) {
    escreva("Alta")
}
se (sexo == falso e altura < 1.75) {
    escreva("Baixo")
}
senao se (sexo == falso e altura >= 1.75) {
    escreva("Alto")
}
```

O algoritmo funciona, mas é claro que existem formas bem melhores e mais simples de escrevê-lo. Mas, para propósitos didáticos, eu vou reescrevê-lo só pra mostrar um conceito novo pra vocês. Antes da reescrita, vejam que eu utilizei uma coisa nova: o operador **e**, que é um operador lógico usado para unir duas condições. Basicamente, ele exige que as duas condições que ele conecta sejam verdadeiras. Visto em **operadores lógicos (criar link interno)**.

Voltando à reescrita, vejam que há uma repetição de operadores de comparação: o **sexo == verdadeiro** está na primeira e na segunda estrutura, e o **sexo == falso** está na terceira e na quarta estrutura. Uma das formas de eliminar isso seria a seguinte:

```
logico sexo
leia(sexo)
real altura
leia(altura)
se (sexo == verdadeiro) {
    se (altura < 1.62) {
        escreva("Baixa")
    }
    senao {
        escreva("Alta")
    }
}
senao {
    se (altura < 1.75) {
        escreva("Baixo")
    }
    senao {
        escreva("Alto")
    }
}
```

Veja que eu coloquei estruturas de controle dentro de outras estruturas de controle. Isso que eu fiz se chama aninhamento. Eu poderia fazer mais níveis de aninhamento, ou seja, colocar mais estruturas de controle dentro dessas estruturas internas. Só que isso não é preciso, e não é recomendado, porque deixa o código complexo. Fomos até o 2º nível de aninhamento. O ideal é ir no máximo até o 3º nível.

O código ficou mais simples de entender e até passou a testar menos condições, com uma performance melhor. É claro que tem maneiras melhores de escrever esse algoritmo, mas eu fiz dessa forma só pra explicar pra você o conceito de aninhamento.

Agora que vimos aninhamento, é importante fazer algumas observações: toda estrutura precisa ser fechada; estruturas de níveis mais externos nunca podem ser fechadas antes de estruturas de níveis mais internos que estão contidas nela.

#### Se vs senao se <a href="#se-vs-senao-se" id="se-vs-senao-se"></a>

Vamos debater um pouco mais as diferenças entre o **se** e o **senao se**. O senao se só é avaliado se as instruções da estrutura anterior a ele não forem executadas. Já o **se** sempre é avaliado. Essa diferença, além de poder mudar o resultado final, pode causar diferenças na performance do programa também.

Como o **senao se** muitas vezes não é avaliado, essa opção tem uma performance melhor. Mas a decisão sobre qual utilizar depende, na verdade, do que você quer fazer. Vou mostrar um exemplo de utilização da estrutura incorreta:

```
real nota_aluno
leia(nota_aluno)
se (nota_aluno >= 0.0 e nota_aluno < 7.0) {
    escreva("Insuficiente\n")
}
se (nota_aluno >= 7.0) {
    escreva("Regular\n")
}
se (nota_aluno >= 8.0) {
    escreva("Bom\n")
}
se (nota_aluno >= 9.0 e nota_aluno <= 10.0) {
    escreva("Ótimo\n")
}
senao {
    escreva("Nota inválida\n")
}
```

Rode o exemplo e digite uma nota entre 9 e 10. O aluno receberá vários conceitos. Isso acontece porque o **se** foi usado quando na verdade o **senao se** deveria ser usado. Um aluno não pode receber mais de um conceito. Por isso, se uma das condições for aceita, nada mais deve ser testado. Assim, o mais correto seria usar apenas um **se** e depois, usar **senao se** e o **senao** para finalizar. Sugiro que você modifique o programa fazendo essas alterações, e depois digite novamente uma nota entre 9 e 10. Se você fizer as alterações corretamente, o aluno sempre receberá apenas um conceito.

### ​​​​​​​Estrutura escolha-caso <a href="#estrutura-escolha-caso" id="estrutura-escolha-caso"></a>

Essa estrutura é equivalente ao _switch_ das linguagens de programação. Nessa estrutura, você pega uma variável qualquer e cria ramificações (_branches_**)** para os valores que a variável pode ter. Exemplo:

```
inteiro titulos
leia(titulos)
escolha (titulos) {
    caso 0:
        escreva("Não ganhou nada")
        pare
    caso 1:
        escreva("Campeão")
        pare
    caso 2:
        escreva("Bicampeão")
        pare
    caso contrario:
        escreva("Mito")
}
```

Cada caso tem que ter exatamente um valor específico. Há linguagens de programação que aceitam um grupo de valores. O Portugol suporta apenas um valor.

Não dá para usar operadores de comparação como nas estruturas de seleção, nem operadores lógicos. Nesse sentido, o **escolha** (_switch_ em inglês) é mais limitado. Quando o **pare** é usado nos casos (exceto no último), o primeiro caso funciona como **se** fosse um se e os casos seguintes funcionam como se fossem **senao se**, só que com as limitações que eu citei.

O **caso contrario** é como se fosse um **senao**. Ele é acionado quando o programa não entra em nenhum dos outros casos. É opcional.

Note que eu coloquei a instrução **pare** em todos os casos, com exceção do último. Porque eu fiz isso? Pro algoritmo não testar os outros casos. Você pode colocar dois casos com o mesmo valor por engano. Sem o **pare**, o algoritmo entraria nos dois casos. Seria um erro lógico. Além disso, mesmo que você não cometa esse erro lógico, se você não colocar o **pare**, o algoritmo vai testar os outros casos enquanto ele não encontrar um **pare**. Colocar o **pare** impede que ele continue testando os outros casos desnecessariamente, melhorando a performance do algoritmo.

Vale lembrar que o valor testado não precisa ser um inteiro. Pode ser uma _**string**_ também. Porém, no Portugol, só são suportados os tipos inteiro e caractere.

***

**O que você aprendeu:**

– Estruturas de controle\
– Fluxogramas de estruturas de controle

### Material Extra <a href="#material-extra" id="material-extra"></a>

{% embed url="https://youtu.be/lKBH1N34SDE" %}
Assista o vídeo e aprimore seu aprendizado sobre o assunto. _Expert Academy_
{% endembed %}

