aula-06.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula 6: Estruturas de controle condicional \n",
    "\n",
    "## O comando if (se, em português)\n",
    "\n",
    "O comando if (se) é uma estrutura de controle condicional utilizada para representar decisões.\n",
    "\n",
    "![figura](img/Picture7.png)\n",
    "\n",
    "Uma estrutura de controle condicional executa uma ou mais instruções mediante à avaliação de uma condição.\n",
    "\n",
    "A notação do comando **if** é\n",
    "\n",
    "<br>if (&lt; expressão &gt;) \n",
    "<br>{\n",
    "<br>    //instruções a serem executadas em caso verdadeiro;\n",
    "<br>}\n",
    "<br>else\n",
    "<br>{\n",
    "<br>    //instruções a serem executadas em caso falso;\n",
    "<br>}\n",
    "\n",
    "Exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include<iostream>\n",
    "\n",
    "// Alterne os valores da expressão lógica entre true e false e veja o resultado\n",
    "{\n",
    "    bool expressaoLogica (false);\n",
    "\n",
    "    if (expressaoLogica) \n",
    "        std::cout << \"Espressão lógica é verdadeira!\";\n",
    "        //instruções a serem executadas em caso verdadeiro;\n",
    "    else\n",
    "        std::cout << \"Espressão lógica é falsa!\";\n",
    "        //instruções a serem executadas em caso falso;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se a expressão lógica do comando **if** for avaliada como verdadeira (valor diferente de 0), são executadas as instruções do bloco **if**, senão, serão executadas as instruções do bloco **else**.\n",
    "\n",
    "Se o **if** ou **else** possuirem apenas uma instrução, os delimitadores de blocos { e } são opcionais.\n",
    "\n",
    "A cláusula **else** é opcional, mas é fortemente recomendada para que haja um feedback do programa em relação ao seu fluxo de execução.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exemplo: O algoritmo em C/C++ a seguir verifica se o usuário acertou um número mágico sorteado pelo programa. Na linguagem C/C++, para sortearmos números, existe a função rand() da biblioteca cstdlib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include<iostream>\n",
    "#include<cstdlib>\n",
    "#include<time.h>\n",
    "\n",
    "srand( (unsigned) time(NULL) );\n",
    "\n",
    "int meu_palpite;\n",
    "\n",
    "int numero_aleatorio = rand();\n",
    "\n",
    "int numero_sorteado = numero_aleatorio % 10;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand() % 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "std::cout << \"Coloque o seu palpite entre 0 e 9\";\n",
    "std::cin >> meu_palpite;\n",
    "\n",
    "//std::cout << \"Número \" << numero_sorteado;\n",
    "    \n",
    "if (meu_palpite == numero_sorteado)\n",
    "    std::cout << \"Certo!!\" ;\n",
    "else if (meu_palpite > numero_sorteado)\n",
    "    std::cout << \"Palpite é maior\";\n",
    "else\n",
    "    std::cout << \"Palpite é menor\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numero_sorteado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## O comando ternário **if** : **?**\n",
    "\n",
    "Você pode usar o operador **?** para substituir os comandos **if-else** na sua forma mais básica:\n",
    "<br>if (&lt;expressão&gt;)\n",
    "<br>\t&lt;instrução 1&gt;;\n",
    "<br>else \n",
    "<br>\t&lt;instrução 2&gt;;\n",
    "\n",
    "O operador **?** é chamado de operador ternário porque ele requer três operandos:\n",
    "\n",
    "<expressão> ? &lt;instrução 1&gt; : &lt;instrução 2&gt;;\n",
    "\n",
    "Exemplo: Nesse caso, o valor 100 é atribuído a Y. Se X fosse menor que 9, o valor 200 seria atribuído a Y. Teste!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int X, Y;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = -1;\n",
    "Y = X>9 ? 100 : 200;\n",
    "std::cout << Y;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A linguagem C/C++ considera o número 0 como uma representação de FALSO e os números diferentes de 0, como uma representação de VERDADEIRO. \n",
    "\n",
    "Para verificar se um valor é diferente de zero, pode-se usar a seguinte avaliação através da estrutura if:\n",
    "\n",
    "if (&lt;valor&gt;)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if (X)\n",
    "    std::cout << \"Numero diferente de 0!!\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## O comando if aninhado\n",
    "\n",
    "O comando if aninhado (ou ladder) é uma estrutura if inserida dentro de uma outra estrutura if.  Utilizamos o if quando temos duas opções de avaliação de uma condição. Utilizamos o if aninhado quando temos mais de duas opções.\n",
    "![figura](img/Picture8.png)\n",
    "\n",
    "Exemplo: informe três números e mostre o maior deles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int a, b, c;\n",
    "int maior;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=100; b=20; c=30;\n",
    "\n",
    "if ((a>=b) && (a>=c))\n",
    "{\n",
    "     maior = a;\n",
    "}\n",
    "else if (b>=c)\n",
    "{\n",
    "     maior = b;\n",
    "}\n",
    "else\n",
    "{\n",
    "     maior = c;\n",
    "}       \n",
    "std::cout << \"O maior número é \" << maior;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## O comando switch\n",
    "\n",
    "Quando temos o objetivo de realizar apenas comparações de igualdades e uma estrutura if aninhada se torna uma longa escada, como no exemplo a seguir, use a estrutura switch.\n",
    "![figura](img/Picture9.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int numero;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numero = 3;\n",
    "\n",
    "if (numero==1)\n",
    "     ;//Opção 1\n",
    "else \n",
    "    if (numero==2)\n",
    "           ;//Opção 2\n",
    "    else \n",
    "        if (numero==3)\n",
    "               ;//Opção 3\n",
    "        else \n",
    "            if (numero==4)\n",
    "                  ;//Opção 4\n",
    "            else\n",
    "                    ;//Opção padrão"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A forma geral do comando switch é:\n",
    "\n",
    "**switch** (&lt;valorcomparado&gt;)\n",
    "<br>{\n",
    "    <br>**case** constante1:\n",
    "        <br>seqüência de instruções;\n",
    "<br>             break;\n",
    "<br>     **case** constante2:\n",
    "<br>             seqüência de instruções;\n",
    "<br>             break;\n",
    "<br>      ...\n",
    "<br>     **case** constanteN:\n",
    "<br>             seqüência de instruções;\n",
    "<br>             break;\n",
    "<br>     **default**:\n",
    "<br>             seqüência de intruções;\n",
    "<br>}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O valorcomparado é comparada contra cada constante dos comandos **case**.\n",
    "\n",
    "Quando o valorcomparado for igual a uma das constantes, as seqüências de instruções abaixo dela são executadas até que se encontre o comando **break** ou o fim do comando switch.\n",
    "\n",
    "Exemplo: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Informe um número de 1 a 3\n",
    "const int CADASTRO = 1;\n",
    "const int CONSULTA = 2;\n",
    "const int EXCLUSAO = 3;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "switch (numero)\n",
    "{\n",
    "    case CADASTRO:\n",
    "          std::cout << \"Executando cadastro....\";\n",
    "          break;\n",
    "    case CONSULTA:\n",
    "          std::cout << \"Executando consulta....\";\n",
    "          break;\n",
    "    case EXCLUSAO:\n",
    "          std::cout << \"Executando exclusão de registro...\";\n",
    "          break;\n",
    "    default:\n",
    "          std::cout << \"Opção inválida!\";   \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercício: Modifique o exemplo acima substituindo os rótulos dos comandos **case** por constantes nomeadas mais relacionadas as instruções que cada comando executa.\n",
    "\n",
    "O padrão ANSI-C especifica que cada comando switch pode ter no máximo 257 comandos case.\n",
    "\n",
    "O comando switch compara apenas igualdades, enquanto o comando IF permite avaliar expressões relacionais e lógicas.\n",
    "\n",
    "Duas constantes do case em um mesmo switch não podem ter valores idênticos.\n",
    "\n",
    "Se constantes de caracteres são usadas em um comando switch, elas são convertidas automaticamente para seus valores inteiros.\n",
    "\n",
    "Em C, as instruções  abaixo de cada **case** são seqüências de comandos e não blocos de comandos, por isso, não se pode fazer declarações de variáveis dentro de uma seqüência de comandos.\n",
    "\n",
    "As variáveis devem ser declaradas no bloco switch antes dos comandos case. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "/* Isto estaria errado em C, mas em C++ está correto */\n",
    "switch(numero)\n",
    "{\n",
    "  case 1:\n",
    "         int t;\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "/* Isto está correto */\n",
    "switch(numero)\n",
    "{\n",
    " int i;\n",
    " case 1:\n",
    "        ;\n",
    "} \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pode-se criar blocos dentro do switch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "/* Isto é correto */\n",
    "switch ( numero )\n",
    "{\n",
    "    case 1:\n",
    "    { /* começo do bloco */\n",
    "      int t;\n",
    "    } /* término do bloco */\n",
    "        break;\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim como existe o comando if aninhado, também existe o comando switch aninhado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1; b = 1;\n",
    "switch(a)\n",
    "{\n",
    "    case 1:\n",
    "        switch(b) \n",
    "        {\n",
    "            case 0: \n",
    "                std::cout << \"erro de divisão por zero\";\n",
    "                break;\n",
    "            default:\n",
    "                std::cout << \"ok!\";\n",
    "        }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício Resolvido \n",
    "\n",
    "Exemplo 1: Escreva um programa C/C++ para exibir o seguinte menu de opções, informe a opção escolhida. Verifique se a opção está entre  as opções válidas, isto é, de 1 a 3. Se a opção for 1, informe o nome e a idade da pessoa. Se for 2, mostre o nome e a idade da pessoa. Se for 3, mostre na tela a mensagem: “Programa finalizado com sucesso!”.\n",
    "\n",
    "**** MENU DE OPÇÕES *****\n",
    "\n",
    "<br>1 – Cadastrar\n",
    "<br>2 – Exibir dados\n",
    "<br>3 – Sair\n",
    "Opção: \n",
    "\n",
    "<br>a) Use o comando **if** aninhado\n",
    "<br>b) Use o comando **switch**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "char nome[30];\n",
    "int idade=0;\n",
    "int opcao=0;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "/* Exibir menu */\n",
    "std::cout << \"***MENU DE OPÇÕES ** \\n\";\n",
    "std::cout << \" 1 – Cadastrar \\n\";\n",
    "std::cout << \" 2 – Exibir dados \\n\";\n",
    "std::cout << \" 3 -  Sair \\n \\n\";\n",
    "\n",
    "std::cout << \" Opção:\";\n",
    "opcao = 4;\n",
    "\n",
    "/* Validar opção */    \n",
    "if (opcao>=1 && opcao<=3) \n",
    "{\n",
    "    if (opcao==1) \n",
    "    {\n",
    "        std::cout << \"Informe o nome.\\n\";\n",
    "        strcpy(nome, \"Ifes Aracruz\");\n",
    "        std::cout << \"Informe a idade em anos.\\n\";\n",
    "        idade = 8;\n",
    "    } \n",
    "    else if (opcao==2) \n",
    "    {\n",
    "        std::cout << \"O nome é \" << nome << std::endl;       \n",
    "        std::cout << \"A idade é \" << idade << \" anos\";\n",
    "    }\n",
    "    else //if (opcao==3)\n",
    "    {\n",
    "        std::cout << \"Programa finalizado com sucesso!!\";\n",
    "    }     \n",
    "}\n",
    "else\n",
    "{\n",
    "    std::cout << \"Você escolheu uma opção inválida!!!\";\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "/* Exibir menu */\n",
    "std::cout << \"***MENU DE OPÇÕES ** \\n\";\n",
    "std::cout << \" 1 – Cadastrar \\n\";\n",
    "std::cout << \" 2 – Exibir dados \\n\";\n",
    "std::cout << \" 3 -  Sair \\n \\n\";\n",
    "\n",
    "std::cout << \" Opção:\";\n",
    "opcao = 4;\n",
    "\n",
    "/* Validar opção */    \n",
    "switch (opcao)\n",
    "{\n",
    "    case 1: \n",
    "        std::cout << \"Informe o nome.\\n\";\n",
    "        strcpy(nome, \"Ifes Aracruz\");\n",
    "        std::cout << \"Informe a idade em anos.\\n\";\n",
    "        idade = 8;\n",
    "    break;\n",
    "    case 2:\n",
    "        std::cout << \"O nome é \" << nome << std::endl;       \n",
    "        std::cout << \"A idade é \" << idade << \" anos\";\n",
    "    break;\n",
    "    case 3:\n",
    "        std::cout << \"Programa finalizado com sucesso!!\";\n",
    "    break;\n",
    "    default:\n",
    "        std::cout << \"Você escolheu uma opção inválida!!!\";\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "int a, b, c;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 30; b = 20; c = 10;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exemplo 2: O que será armazenado nas variáveis a, b, c no exemplo a seguir?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30"
     ]
    }
   ],
   "source": [
    "#include<iostream>\n",
    "// algoritmo de ordenação crescente dos valores existentes em a, b, c.\n",
    "{\n",
    "    int aux;\n",
    "    if(a > b) //a = 30; b = 20; c = 10;\n",
    "    { \n",
    "        aux = a; //aux = 30\n",
    "        a = b;   //a = 20; b = 20; c = 10;\n",
    "        b = aux; //a = 20; b = 30; c = 10;\n",
    "    }\n",
    "    if(a > c) //a = 20; b = 30; c = 10;\n",
    "    { \n",
    "        aux = a; //aux = 20\n",
    "        a = c;   //a = 10; b = 30; c = 10;\n",
    "        c = aux; //a = 10; b = 30; c = 20;\n",
    "    }\n",
    "    if(b > c) //a = 10; b = 30; c = 20;\n",
    "    { \n",
    "        aux = b; //aux = 30\n",
    "        b = c;   //a = 10; b = 20; c = 20;\n",
    "        c = aux; //a = 10; b = 20; c = 30;\n",
    "    }\n",
    "}\n",
    "//a = 10; b = 20; c = 30;\n",
    "std::cout << a << std::endl << b << std::endl << c;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boas práticas de programação\n",
    "switch é elegante\n",
    "\n",
    "if é decisão\n",
    "\n",
    "if aninhado é confusão"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercícios Propostos\n",
    "- Ler um número e, se ele for positivo, imprimir seu inverso; caso contrário, imprimir o valor absoluto do número.\n",
    "- Ler um número e imprimir se ele é par ou ímpar.\n",
    "- Ler um número e imprimir se ele é positivo, negativo ou nulo.\n",
    "- Modifique o exemplo 2 acima para utilizar **if** aninhado de forma que o computador execute no máximo dois testes para ordenar os números.\n",
    "- Modifique o exemplo 2 acima para encontrar o maior dos três números.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++14",
   "language": "C++14",
   "name": "xcpp14"
  },
  "language_info": {
   "codemirror_mode": "text/x-c++src",
   "file_extension": ".cpp",
   "mimetype": "text/x-c++src",
   "name": "c++",
   "version": "14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}