aula-07.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula 7: Estruturas de controle de repetição\n",
    "\n",
    "Em C/C++, assim como em outras linguagens, existem os comandos de iteração (chamados laços) que permitem que um certo conjunto de instruções possam ser executados repetidamente com base em uma condição.\n",
    "\n",
    "Em C/C++, esses comandos são os laços FOR (para), WHILE (enquanto – com pré-condição), DO WHILE (faça enquanto – com pós-condição)\n",
    "\n",
    "## O laço while\n",
    "\n",
    "A sintaxe do laço while é:\n",
    "<br>while(condicao)\n",
    "<br>{\n",
    "<br>}\n",
    "\n",
    "A semântica é: repita enquanto uma condição for verdadeira e pare quando ela for falsa.\n",
    "\n",
    "A estrutura while é a estrutura mais poderosa de repetição.\n",
    "\n",
    "As variáveis da expressão lógica da condição deverão ser inicializadas antes de iniciar o laço WHILE;\n",
    "\n",
    "As variáveis da expressão lógica da condição devem ser atualizadas dentro do laço WHILE, preferencialmente no final do bloco;\n",
    "\n",
    "As variáveis são inicializadas e atualizadas por atribuições (=) ou por comandos de entrada de dados (scanf, gets, getchar,...)\n",
    "\n",
    "Exemplo: O programa a seguir repete o incremento de um contador enquanto for menor que 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "/* Inicialização da variável */\n",
    "\n",
    "int contador (0);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include<iostream>\n",
    "\n",
    "contador = 0;\n",
    "while (contador < 10)\n",
    "    std::cout << ++contador << std::endl;\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contador"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Atenção**: Tenha certeza de que a condição de repetição em algum momento será falsa. Caso contrário, o seu programa poderá entrar em loop infinito.\n",
    "\n",
    "## O comando do-while\n",
    "\n",
    "O comando do-while é uma estrutura de controle de repetição que, ao contrário dos laços for e while, testa a condição ao final de cada iteração. A forma geral da estrutura do-while é\n",
    "<br>do\n",
    "<br>{\n",
    "<br>} while (condicao);\n",
    "\n",
    "Essa estrutura é mais utilizada quando deseja-se que a primeira iteração seja realizada sem verificação da condicao.\n",
    "\n",
    "Recomenda-se fortemente usar os delimitadores de blocos ({ }) mesmo quando houver apenas uma instrução, para não haver confusão.\n",
    "\n",
    "Exemplo: a programação a seguir repete o sorteio de um número enquanto esse número não está no intervalo de 1 a 5."
   ]
  },
  {
   "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 numero_aleatorio;\n",
    "\n",
    "int numero_sorteado;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numero_aleatorio = rand();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(numero_aleatorio % 10) + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "do {\n",
    "    numero_aleatorio = rand();\n",
    "    numero_sorteado = (numero_aleatorio % 100) + 1;\n",
    "    std::cout << numero_sorteado << std::endl;\n",
    "} while ( !(numero_sorteado>=1 && numero_sorteado<=5) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercício: De que outra forma a expressão da condição do do-while poderia ser escrita sem alterar o resultado?  \n",
    "\n",
    "!(numero>=1 && numero<=5)\n",
    "\n",
    "**Atenção**: No do-while, as variáveis de controle da repetição não precisam ser inicializadas, mas precisam ser atualizadas dentro do laço para não entrar em loop.\n",
    "\n",
    "## O laço for\n",
    "\n",
    "O laço **for**, na maioria das linguagens de programação, executa um conjunto de instruções por um número fixo de iterações. \n",
    "\n",
    "![figura](img/Picture11.png)\n",
    "\n",
    "Em C/C++, mais do que isso, o laço **for** fornece maior flexibilidade.\n",
    "\n",
    "A forma geral do laço **for** em C/C++ é :\n",
    "<br>for (inicialização; condição; incremento)\n",
    "<br>{\n",
    "<br>}\n",
    "\n",
    "- Inicialização: em geral é um comando de atribuição que inicializa uma variável que controla o laço de repetição.\n",
    "- Condição: expressão lógica que informa quando o laço termina\n",
    "- Incremento: indica como a variável de controle varia a cada repetição.\n",
    "\n",
    "Quando houver apenas uma instrução no laço for, são opcionais os delimitadores de blocos {}.\n",
    "\n",
    "Exemplo: O programa a seguir exibe os números de 1 a 100.\n",
    "\n",
    "    x=1 : A variável de controle x é inicializada com 1\n",
    "    x<=100 : A condição de repetição é que x seja menor ou igual a 100\n",
    "    x++ : A cada iteração x é  incrementada em 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for (int contador=1; contador<=100; contador++)\n",
    "    std::cout << contador << \" \";\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exemplo: o laço for a seguir é executado até que a variável de controle x seja igual a 65.\n",
    "\n",
    "    x=100 : x é inicializado com 100;\n",
    "    x!=65 : a repetição se mantém até que x seja 65\n",
    "    x-=5 : a cada iteração, x é decrementado de 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for (int x=100; x!=65; x-=5)\n",
    "{\n",
    "    int z = x*x;\n",
    "    std::cout << \"O quadrado de \" << x << \" é \" << z << std::endl;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exemplo: Exibir os n primeiros termos de uma PG."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include<iostream>\n",
    "\n",
    "float primeiroTermo, razao, n, termo;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "primeiroTermo=2;\n",
    "razao=2;\n",
    "n=4;\n",
    "termo = primeiroTermo;\n",
    "for(int i=0; i<n; i++)\n",
    "{\n",
    "    std::cout << termo << \" \";\n",
    "    termo *= razao;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variações do laço FOR\n",
    "\n",
    "Uma das operações mais comuns usa o operador “,” para permitir que duas ou mais variáveis controlem um laço."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for (int x=0, y=0; x+y<10; ++x)\n",
    "    std::cout << x << \" \" << y << \" \";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A  expressão condicional não precisa envolver um teste com a variável que controla o laço e algum valor final. Na realidade, a condição pode ser qualquer sentença relacional ou lógica.\n",
    "\n",
    "**Atenção**: Fique atento para que o laço não entre em loop!!\n",
    "\n",
    "Algumas partes da definição do laço for não precisam existir.\n",
    "\n",
    "Exemplo: o laço a seguir será executado até que o usuário digite o número 123:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for (int x=0; x!=123;  ) \n",
    "    x++;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exemplo: no laço a seguir a variável x é inicializada antes do loop e atualizada dentro do laço."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int x=0;\n",
    "for ( ; x<10 ; )\n",
    "     ++x;\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### O laço infinito (loop)\n",
    "\n",
    "Um laço infinito FOR é aquele em que a condição de controle nunca se torna falsa ou não existe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ( ; ; ) \n",
    "    std::cout << \"Executando para sempre \\n\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### O comando break interrompe um laço.\n",
    "\n",
    "Exemplo: o laço a seguir será executado até que x seja igual a 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "for (int x=0;  ; x++)\n",
    "     if (x>=10)\n",
    "         break;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Laços for sem corpos\n",
    "\n",
    "Em geral, são usados para gerarem tempos de espera no programa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Terminou\n"
     ]
    }
   ],
   "source": [
    "#include <iostream>\n",
    "{\n",
    "    unsigned long long int tempoDeEspera = 1000000000;\n",
    "    for (unsigned long long int t=0; t<tempoDeEspera; t++)\n",
    "        ;\n",
    "    std::cout << \"Terminou\" << std::endl;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a b c d e f g h i j k l m n o p q r s t u v w x y z "
     ]
    }
   ],
   "source": [
    "/*  Este programa imprimir as letras de a até z utilizando o comando de repetição for. */\n",
    "\n",
    "#include<iostream>\n",
    "for(char letra='a'; letra<='z'; letra++)\n",
    "      std::cout << letra << \" \";\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "98"
     ]
    }
   ],
   "source": [
    "{\n",
    "    char letra='b';\n",
    "    std::cout << (int)letra;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A soma é:240"
     ]
    }
   ],
   "source": [
    "/* Este programa calcula a soma dos 10 primeiros elementos de uma PA com a1=15 e r=2, imprimindo cada elemento gerado. Use o comando for de repetição \n",
    "*/\n",
    "\n",
    "#include<iostream>\n",
    "\n",
    "const int a1=15;\n",
    "const int r=2;\n",
    "const int n=10;\n",
    "int i, an=a1, soma=a1;   \n",
    "\n",
    "/* Soma da PA: an = a1 + n * r; soma = soma + an */\n",
    "for(i=2; i<=n; i++)\n",
    "{       \n",
    "    an += r;\n",
    "    soma += an;       \n",
    "}\n",
    "\n",
    "std::cout << \"A soma é:\" << soma;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comandos de desvio\n",
    "\n",
    "### Comando return\n",
    "\n",
    "O comando **return** abandona a execução de uma função, retorna um valor e o programa volta ao ponto de execução de onde a função foi chamada.\n",
    "Forma geral:\n",
    "\n",
    "    **return** expressao;\n",
    "\n",
    "Uma expressão pode ser um valor, uma expressão aritmética ou lógica.\n",
    "\n",
    "### Comando goto\n",
    "\n",
    "O comando **goto** desvia o fluxo de execução de um programa para um outro ponto do programa, desde que esse ponto seja identificado por um rótulo.\n",
    "\n",
    "A forma geral do goto é\n",
    "\n",
    "    **goto** rotulo;\n",
    "\n",
    "Exemplo: Este trecho de código conta até 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100"
     ]
    }
   ],
   "source": [
    "#include<iostream>\n",
    "int x=1;\n",
    "loop1:\n",
    "    x++;\n",
    "    if (x<100) \n",
    "        goto loop1;\n",
    "std::cout << x;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comando break\n",
    "\n",
    "O comando **break** interrompe um comando switch ou um laço for, while ou do-while.\n",
    "   \n",
    "O break força a parada de um laço de repetição sem testar a condição.  \n",
    "\n",
    "Exemplo: O laço a seguir exibe 100 vezes “olá mundo”, mas é interrompido depois da décima vez."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Olá, mundo! \n",
      "\n",
      " Olá, mundo! \n",
      "\n",
      " Olá, mundo! \n",
      "\n",
      " Olá, mundo! \n",
      "\n",
      " Olá, mundo! \n",
      "\n",
      " Olá, mundo! \n",
      "\n",
      " Olá, mundo! \n",
      "\n",
      " Olá, mundo! \n",
      "\n",
      " Olá, mundo! \n",
      "\n",
      " Olá, mundo! \n"
     ]
    }
   ],
   "source": [
    "for (int i=0; i<100; i++)\n",
    "{\n",
    "    std::cout << \"\\n Olá, mundo! \\n\";\n",
    "    if (i>=9) \n",
    "    {\n",
    "          break;\n",
    "    } \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comando continue\n",
    "\n",
    "O comando continue interrompe a execução do loop em uma iteração, mas vai para a próxima iteração a partir do teste das condições.\n",
    "\n",
    "Exemplo: a programação a seguir mostra apenas os números pares entre 1 e 100. Os ímpares são “pulados”."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98 100 "
     ]
    }
   ],
   "source": [
    "for(int i=1; i<=100; i++)\n",
    "{\n",
    "     if (!(i%2==0)) \n",
    "        continue;\n",
    "     std::cout << i << \" \";\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t1-2\t1-3\t1-4\t1-5\t1-6\t1-7\t1-8\t1-9\t1-10\n",
      "\t\t2-3\t2-4\t2-5\t2-6\t2-7\t2-8\t2-9\t2-10\n",
      "\t\t\t3-4\t3-5\t3-6\t3-7\t3-8\t3-9\t3-10\n",
      "\t\t\t\t4-5\t4-6\t4-7\t4-8\t4-9\t4-10\n",
      "\t\t\t\t\t5-6\t5-7\t5-8\t5-9\t5-10\n",
      "\t\t\t\t\t\t6-7\t6-8\t6-9\t6-10\n",
      "\t\t\t\t\t\t\t7-8\t7-9\t7-10\n",
      "\t\t\t\t\t\t\t\t8-9\t8-10\n",
      "\t\t\t\t\t\t\t\t\t9-10\n",
      "\t\t\t\t\t\t\t\t\t\n"
     ]
    }
   ],
   "source": [
    "/* Imprimir os elementos da matriz triangular superior. Ou seja, imprimir os elementos ACIMA DA DIAGONAL PRINCIPAL */ \n",
    "for(int L=1;L<=9;L++)\n",
    "{\n",
    "    for(int c=L+1;c<=10;c++)\n",
    "    { \n",
    "        std::cout << \"\\t\" << L << \"-\" << c; \n",
    "    } \n",
    "    std::cout << \"\\n\"; \n",
    "    for(int t=1;t<=L;t++) \n",
    "    {\n",
    "        std::cout << \"\\t\";\n",
    "    }\n",
    "}\n",
    "std::cout << \"\\n\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boas práticas de programação\n",
    "\n",
    "- Para que seu programa não entre em loop, fique atento para a atualização das variáveis da expressão lógica da estrutura de repetição. \n",
    "\n",
    "- Para repetições que você conhece o número de vezes, dê preferência à estrutura for.\n",
    "\n",
    "- Evite comandos de desvio e não use GOTO!\n",
    "\n",
    "## Exercícios propostos\n",
    "\n",
    "- Imprimir todos os números de 100 até 1.\n",
    "- Imprimir os múltiplos de 5, no intervalo de 1 até 500.\n",
    "- Criar um algoritmo que calcule e imprima o valor de $b^n$. O valor de n deverá ser maior do que 1 e inteiro e o valor de b maior ou igual a 2 e inteiro.\n",
    "- Criar um algoritmo que imprima a tabela de conversão de graus Celsius-Fahrenheit para o intervalo desejado pelo usuário. O algoritmo deve conter o limite superior, o limite inferior do intervalo e o decremento em Fahrenheit.\n",
    "- Criar um algoritmo que imprima os 10 primeiros termos da série de Fibonacci. Observação: os dois primeiros termos desta série são 1 e 1 e os demais são gerados a partir da soma dos anteriores."
   ]
  },
  {
   "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
}