Estruturas de controle - sequencial e decisão em C++

       ESTRUTURA DE CONTROLE          

As estruturas de controlo exercem um papel preponderante na criação de um programa, e independentemente da linguagem de programação utilizada as estruturas de controle é que determinam o fluxo da execução de um programa. Elas podem ser:

• Estruturas sequênciais
• Estruturas de decisão; 
• Estruturas de repetição. 

      Estrutura de controle sequencial
Nesse tipo de estrutura, o fluxo do programa é executada de forma sequencial e cada instrução é executado apenas uma única vez e após o termino da instrução anterior.

    Comando 1
    Comando 2
    Comando 3
       …
    Comando n

A sintaxe de um programa que obedece a estrutura sequencial é ilustrada acima. Numa programa que obedece uma estrutura sequencial podem existir n comandos e cada comando é executado após o comando anterior e é mantida a ordem de execução.

Características principais de um programa em com a estrutura sequencial:

• As instruções são executadas de forma sequencial;
• É mantida a ordem de execução das instruções e cada instrução é executada uma única vez e após o término da anterior.

Um exemplo de um programa sequencial em C++ é apresentado a seguir

Exemplo 1

#include <iostream>

using namespace std;
int main{
        cout("Bem vindo ao Sistema \n");
        cout("Obrigado pela sua presença");
}

Como resultado de execução o programa ira exibir a seguinte mensagem:

Bem vindo ao sistema!     
Obrigado pela sua presença

Neste exemplo temos um programa em C que exibe na tela duas mensagens sendo a primeira Bem vindo ao sistema e a segunda Obrigado pela sua presença. A ordem de exibição das mensagens satisfaz a ordem de execução do programa.

No exemplo a seguir também estamos perante o mesmo cenário em que o resultado da execução corresponde a ordem de execução do programa. 

   Exemplo 2:

    #include <stdlib>
    int main (){
          int n1, n2, s;
          cout(‘Introduz o primeiro número’);
          cin(n1);
          cout(‘Introduz o segundo númeroa’);
          cin(n2);
          s = n1 + n2;
          cout("A soma é igual %d : ",s);
     }

Programa que efectua a soma de dois números

Descrição do código linha por linha

1. Declaração de variáveis: São declaradas as variáveis n1, n2 e s para armazenar o primeiro valor, o segundo número e a soma respectivamente.
2. Recorre-se ao comando cout para exibibir a mensagem Introduz o primeiro número : e posisiona o cursor na linha seguinte
3. Recorrendo ao comando cin Lê-se o primeiro número introduzido usando o teclado
4. Recorre-se ao comando cout para exibibir a mensagem Introduz o segundo número : e posisiona o cursor na linha seguinte graças a presença de \n
5. Lê o segundo número introduzido
6. Efectua-se a soma dos dois números e armazena se o resultado da execução passo a passo
7. Exibe a soma determinada na linha anterior e a mensagem A soma é igual.
8. Termina a execução.

            Estrutura de decisão            

Nem sempre que as situações da vida são lineares, em várias situações nós precisamos tomar decisões que dependem da satisfação de determinadas condições. Por exemplo, num dia de sol com uma temperatura acima de 35º C para definirmos a nossa agenda para o final de semana, tipo de roupa a usar, depende da temperatura que se faz sentir, se a temperatura for abaixo de zero graus não fará sentido usarmos roupa de verão.

Em uma estrutura de decisão pode existir uma condição ou várias que definem o fluxo de execução da instrução ou conjunto de instruções, mas a execução de uma determinada instrução depende da satisfação de uma determinada condição podendo haver execução de uma instrução quando esta condição for verdadeira e outra instrução quando a condição for falsa. Nesse contexto uma condição é uma expressão lógica.

Na programação temos um cenário similar em que o fluxo da execução de uma programação depende da satisfação de uma dada condição podendo haver execução de uma instrução quando esta condição for verdadeira e outra instrução quando a condição for falsa.

As estruturas de decisão que podem definir fluxo de execução podem ser:

• De decisão simples
• Composta
• De selecção

            Estrutura de decisão simples            

Numa estrutura de decisão simples ou estrutura de desvio condicional simples, temos a execução de uma instrução ou conjunto de instruções apenas quando a expressão lógica for verdadeira. 

Sintaxe

  If (condição)
     Intrução;

A estrutura de decisão simples é representada pela seguinte sintaxe:

No exemplo 3 temos uma estrutura de decisão simples que exibe uma mensagem Aprovado quando o valor da média é superior a 10.

Exemplo 3

    #include <stdio.h> 
    int main (){
        float t1, t2, media;
        cout("Introduz o valor de teste1 e teste 2");
        cin(t1,t2);
        media = (t1 + t2)/2
        If (media >10) 
        cout("Aprovado");
    } 

          Estrutura de decisão composta          

Numa estrutura de decisão composta ou estrutura de desvio condicional composta, o resultado da execução depende da avaliação da expressão lógica. Se a expressão lógica for verdadeira, uma instrução ou conjunto de instruções serão executados e caso a avaliação da mesma expressão for falsa(caso contrário), uma instrução ou conjunto de instruções serão executados. 

A estrutura de decisão composta é representada pela seguinte sintaxe:

Sintaxe:

      If (condição) {
          Intrução 1

      }else{

          Intrução 2

      }
No exemplo 2 temos uma estrutura de decisão composta na qual é avaliada a media, e se a media for maior que 10 será exibida a mensagem Aprovado e caso contrário é exibida a mensagem Reprovado.

Exemplo 4

            #include <stdio.h> 
         int main (){
             float t1, t2, media;
             cout("Introduz o valor de teste1 e teste 2");
             cin(t1,t2);
             media = (t1 + t2)/2
             If (media >10) {
                cout("Aprovado");
             else
                cout("Reprovado" );
          } 

          Estrutura de decisão múltipla          

Numa estrutura de decisão múltipla, o resultado da execução depende da avaliação da expressão lógica e podem existir inúmeras condições. A primeira condição é antecedida por um if, e as restantes por um else if. Se a expressão lógica for verdadeira, uma instrução ou conjunto de instruções serão executados e caso a avaliação da mesma expressão for falsa(caso contrário), uma instrução ou conjunto de instruções serão executados.  

A estrutura de decisão múltipla é representada pela seguinte sintaxe:

Sintaxe:

      If (condição 1) {
          Intrução 1;

      }else if(condição 2){

          Intrução 2;

      }else if(condição 3){

                        Intrução 3;

      }       ...

       else if (condição n){

          instrução n;

      }

No exemplo 5 temos uma estrutura de decisão múltipla na qual é avaliada a media, e se a media for maior ou igual a 14 será exibida a mensagem Dispensado, se a média for maior ou igual a 10 será exibida a mensagem Admitido e caso contrário é exibida a mensagem Excluído.

Exemplo 5:

         #include <stdio.h>
         int main (){
             float t1, t2, media;
             cout("Introduz o valor de teste1 e teste 2");
             cin(t1,t2);
             media = (t1 + t2)/2
             If (media >=14) {
                cout("Dispensado");
             }else If (media >=10) {

                cout("Admitido" );

             }else{

                cout("Excluído" );

             }

          } 



            Comando Switch case               

Uma instrução switch permite que uma variável seja testada quanto à igualdade em relação a uma lista de valores. Cada valor é chamado de caso, e a variável que está sendo activada é verificada para cada caso de switch.

Este comando permite nos evitar o recurso ao if, fornecendo nós o switch como um comando alternativo. É uma forma de reduzir a complexidade de vários if … else encadeados.
É muito utilizado, principalmente para uso em estruturas de menu.

Sintaxe

     switch(expressao) { 

           case (constante) : 

                 instrução 1; 

                 break; // opcional 

           case (constante) : 

                 instrução 2; 

                 break; // opcional 

          case (constante) : 

                 instrução 3; 

                 break; // opcional

               ...

          case (constante) : 

                 instrução n; 

                 break; // opcional

          default : // opcional

                 instruções;

      }

As regras a seguir se aplicam a uma instrução switch case:

• A expressão usada em uma instrução switch deve ter um tipo inteiro ou char ou ser de um tipo de classe em que a classe tenha uma única função de conversão para um tipo integral ou enumerado.
• pode ter qualquer número de instruções case em um switch. Cada case é seguido pelo valor a ser comparado e dois pontos.
• A constante em um case deve ser o mesmo tipo de dados que a variável definida no switch e deve ser uma constante ou literal.
• Quando a variável que está sendo considerada é igual a um case, as instruções que seguem o case serão executadas até que uma declaração de interrupção seja alcançada.
• Quando uma instrução de interrupção é alcançada, o switch termina e o fluxo de controle salta para a próxima linha após a instrução do switch.

Nem todo case precisa conter uma interrupção. Se nenhuma interrupção aparecer, o fluxo de controle avança para os casos subsequentes até que uma interrupção seja atingida.

Uma instrução de switch pode ter um case predefinido opcional, que deve aparecer no final do switch. O case padrão pode ser usado para executar uma tarefa quando nenhum dos casos for verdadeiro. Nenhuma interrupção é necessária no case predifinido.

No exemplo a seguir é ilustrado um programa que verifica o dia da semana, o utilizador digita um número no intervalo de 1 a 7 e o programa vai retornar o dia da semana equivalente ao número.

Exemplo 6:

       #include <stdio.h>

       int main (void ){

           int valor;

           cout ("Digite um valor de 1 a 7: ");

           cin(valor);

   

           switch ( valor ){

                   case 1 :

                   cout ("Domingo\n");

                   break;

                   case 2 :

                   cout ("Segunda\n");

                   break;

                   case 3 :

                   cout ("Terça\n");

                   break;

                   case 4 :

                   cout ("Quarta\n");

                   break;

                   case 5 :

                   cout ("Quinta\n");

                   break;

                   case 6 : 

                   cout ("Sexta\n");

                   break;

                   case 7 :

                   cout ("Sabado\n");

                   break;

                   default :

                   cout ("Valor invalido!\n");

            }

       return 0;

       }

Exercicios de aplicação