Aulas - Algoritmos

Prévia do material em texto

Aula 1
Introdução à lógica de programação
Nesta aula, vamos apresentar um breve histórico das linguagens de programação e mostrar como a maioria dos computadores funciona internamente e seus principais componentes.
Entendo a programação...
A Informática é uma área que permeia quase todas as outras áreas. Na Engenharia, Agronomia, Arquitetura e até nas artes podemos encontrar exemplos de aplicações da tecnologia da informação. Um sistema computacional é composto pela combinação de hardware e software.
O que é lógica de programação?
Exemplo 1: Um bebê sabe que precisa chorar para receber atenção;
Exemplo 2: Para pegar a caneta que está dentro da gaveta fechada, precisamos primeiro abrir a gaveta para depois pegar a caneta.
O pensamento (e a lógica) pode ser expresso por meio da palavra falada ou da palavra escrita. Um mesmo pensamento pode ser expresso em inúmeros idiomas, tanto oralmente quanto por escrito.
A forma de representar o pensamento é muito importante na programação de computadores porque, quando um programador ou analista pensa em um programa, ele precisa saber expressar seu raciocínio por meio de uma representação ou mesmo de uma linguagem gráfica. Nas empresas, isso é muito comum. Existem diagramas específicos para representar fluxos de processos e outros procedimentos. Por exemplo: os organogramas, que mostram a divisão funcional de pessoas; as plantas de arquitetura e outros exemplos nos quais encontramos desenhos que representam algum processo ou projeto.
Atenção!
Na informática não é diferente, e usamos alguns recursos para representar o conhecimento. Os exemplos mais comuns são os fluxogramas e os algoritmos. Você vai perceber que esses recursos não são exclusivos da área. Eles podem e devem ser usados em várias situações do nosso dia.
Os fluxogramas
Em qualquer tipo de tamanho de projeto, sendo ele de software ou não, é feito um planejamento ou um esboço do que será desenvolvido. Esses esboços são muito importantes porque ajudam tanto a equipe de desenvolvimento quanto o cliente a entender melhor o problema a ser resolvido. Servem também como uma ferramenta de apoio e linguagem comum entre quem está desenvolvendo e o cliente. Uma forma de criar o esboço de um projeto em programação de computadores é o fluxograma (O fluxograma é uma representação gráfica de um processo ou fluxo de trabalho, feito com figuras geométricas padronizadas e setas ligando cada figura. Também pode ser definido como o gráfico que representa o caminho feito por algum elemento (como, por exemplo, um documento), entre os vários departamentos de uma empresa).
Saiba mais
A representação gráfica possibilita que entendamos, de forma rápida e fácil, uma solução para um problema e mostra a como as informações ou documentos entre os elementos que participam no processo são transformadas.
Criação de fluxogramas
A existência de fluxogramas na representação de processos é fundamental para a padronização do trabalho. Além de auxiliar a compreensão dos processos desenvolvidos em cada departamento ou área da empresa, pode indicar oportunidades de otimização. Veja dois exemplos de fluxogramas:
Suponha que um processo vá ser representado por um retângulo. E para o início e fim do desenho, vamos usar um retângulo arredondado. Sendo assim, para ligar um carro, o desenho do fluxo seria assim:
Vamos examinar um exemplo de outra situação: o objetivo é determinar o valor do saldo no final do 3º mês de uma aplicação financeira, com investimento inicial de R$100,00, com juros de 1% ao mês. Observe o fluxograma a seguir:
No nosso exemplo, temos alguns valores que podem variar:
i: valor do investimento inicial;
j: a taxa de juros;
p: saldo ao final do 1º mês;
s: saldo ao final do 2º mês;
t: saldo ao final do 3º mês.
Você sabe o significado de cada figura nos fluxogramas?
No fluxograma, vimos que existem figuras diferentes, cada uma delas com um significado. Observe:
Observe agora um fluxograma um pouco mais complexo:
Não diga que é complicado! Ele é apenas um pouco mais elaborado do que os outros e mostra que nem todas as tarefas são sequenciais.
Para terminar, observe que também existem fluxogramas para problemas que não sejam exclusivamente matemáticos. Veja o fluxograma a seguir:
Esse é mais simples, né?
A outra forma que vamos estudar, a qual representa uma solução de um problema, é o famoso algoritmo.
Algoritmos
O algoritmo é a representação do pensamento descrito como uma sequência de passos que visam atingir um objetivo.
Quer ver um exemplo?
Olhe como eles são mais simples e corriqueiros do que imaginamos:
Receita de bolo;
Orientação para se chegar a algum endereço;
Um manual de instruções.
E qual a importância dos algoritmos na programação?
Eles servem para representar o raciocínio, independentemente de detalhes computacionais, ou seja, deixam os detalhes que uma linguagem de programação possui. Esses detalhes podem ser acrescentados mais tarde. O importante é focalizar primeiro na resolução algorítmica do problema, possibilitando depois codificá-la em qualquer linguagem.
Escrever um algoritmo é fácil. E quanto mais simples você escrever, mais claro e objetivo ele será.
Quer ver um exemplo?
Como fazemos para trocar uma lâmpada? Trata-se de uma sequência de passos, não é mesmo?
Temos que:
Pegar uma escada;
Posicionar a escada embaixo da lâmpada;
Buscar uma lâmpada nova;
Subir na escada;
Retirar a lâmpada velha;
Colocar uma lâmpada nova.
Saiba mais
Dependendo da equipe, do problema ou do projeto, é bom usar uma dessas duas formas (algoritmos ou fluxogramas), ou até mesmo as duas formas simultaneamente, se for o caso, para poder esclarecer com precisão a solução de um determinado problema. O algoritmo é muito usado em várias situações. Na matemática, existem vários tipos de algoritmos, assim como na genética em Biologia e até mesmo na Administração e Economia.
Como escrever um algoritmo?
A forma mais comum de escrever um algoritmo é usar uma linguagem chamada de português estruturado ou portugol. Esta forma é a que mais se aproxima da definição de algoritmos como conhecemos. O português estruturado é uma simplificação da nossa linguagem natural, na qual usamos frases simples e estruturas que possuem um significado muito bem definido. Apesar disso, a aparência do português estruturado é muito semelhante a uma linguagem de programação tradicional. Ele possui um conjunto de palavras e regras que formam as sentenças válidas e compõem a sintaxe da linguagem. Veja o exemplo de um algoritmo em português estruturado na tela do computador:
Veja que temos frases curtas e imperativas, ou seja, estamos “mandando” o computador executar pequenas ordens que devem ser muito claras.
Veja outro exemplo de algoritmo:
Viu que um algoritmo não precisa ser tão “matemático” ou “computacional” como o primeiro exemplo? Ele também serve para documentar qualquer tipo de processo, em qualquer área.
Atenção
Você já entendeu que é possível representar programas de computador ou processos por meio de figuras (no fluxograma) ou por texto (no caso de algoritmo). É preciso agora entender como de fato os computadores são programados. Para isto, usamos uma linguagem de programação.
Linguagens de programação
As linguagens de programação não surgiram recentemente. Elas fazem parte da história da computação, de uma maneira muito marcante. A figura a seguir mostra um pequeno resumo de como as linguagens de programação surgiram ao longo do tempo, desde a década de 1960:
Reflexão
Em 1960, não tínhamos a internet na forma como é hoje, logo a linguagem Fortran, que é uma das primeiras a serem usadas em grande escala, não serve para programar para a internet. Essa linguagem era voltada para as características de sua época como cálculos científicos e outros. E assim ocorreu com as outras linguagens. Veja como evoluíram até chegar à linguagem C++, que vamos estudar nesta disciplina. E veja que o C++ deu origem a duas grandes linguagens muito usadas atualmente: o Java e o C#.
A divisão dahistória do computador em gerações
Primeira geração
A primeira geração dos computadores foi marcada pelo ENIAC (Electrical Numerical Integrator and Calculator). Ele foi criado em 1943 por John Eckert e John Mauchly e era bem diferente do que conhecemos por um computador atual. Imagine um computador que pesava 30 toneladas e ocupava 180 metros quadrados (é maior do que muitos apartamentos atuais) e fazia incríveis 5 mil somas ou 360 multiplicações por segundo. Para você ter uma ideia, o Intel I7 980-X pode fazer 20.000.000.000 operações por segundo (20 GFlops). Mas para a época, era uma grande máquina e um belo avanço. Além de ser muito grande, o ENIAC possuía mais de 17 mil válvulas. Naquela época não existiam os componentes eletrônicos que temos hoje, então eles usavam válvulas para poder criar os circuitos. O problema das válvulas é que elas esquentavam demais e, sendo assim, o ENIAC emitia mais de 200.000 watts de calor. Uma válvula é semelhante a uma lâmpada incandescente. Em 1951, foi criado o UNIVAC (Universal Automatic Computer). Os computadores desta época eram diferentes dos atuais em vários sentidos. Um deles é que os computadores eram construídos com finalidades muito específicas. No caso do UNIVAC, sua principal aplicação era a apuração do censo populacional dos EUA.
Segunda geração
A segunda geração dos computadores ficou marcada pelo desenvolvimento do transístor em 1947. Os transístores oferecem muitas vantagens em relação às válvulas:
São muito menores que as válvulas;
Muito mais econômicos;
Muito mais rápidos;
Não esquentam.
Nessa geração, também apareceram linguagens de programação que ainda são usadas até hoje em algumas aplicações. Entre elas, temos o Assembly, Cobol e Fortran. Porém, os computadores ainda não eram pessoais. Ou seja, eram criados apenas para aplicações específicas, e muitas delas para aplicações militares (1947 foi o final da II Guerra Mundial e início da chamada Guerra Fria).
Terceira geração
A terceira geração dos computadores foi no período de 1965 a 1970. Outro grande avanço na eletrônica contribuiu diretamente na arquitetura dos computadores: o surgimento do circuito integrado (CI), também chamado de microchip. O CI é uma “pastilha” que contém muitos circuitos eletrônicos dentro dela. A indústria de miniaturização conseguiu, ao longo dos tempos, deixar os componentes eletrônicos cada vez menores. Assim, contribuiu também com a indústria de computadores, diminuindo seu tamanho e deixando-os serem consumidos por pessoas e entusiastas de eletrônica durante essa época. Um grande exemplo de computador dessa época foi o IBM Série 360, de 1964. Você percebe pela sua figura que ele é bem menor que seus antecessores e era usado comercialmente e para fins científicos.
Quarta geração
A quarta geração tem início no começo da década de 1970. Os computadores ficam menores ainda e começam a usar o microprocessador, que é um circuito com vários circuitos eletrônicos presentes internamente. Um único microprocessador dessa época tinha mais poder de processamento do que os ENIAC da primeira geração. Uma calculadora eletrônica em 1977, por exemplo, conseguia fazer 250 milhões de multiplicações por segundo. Comparado com o ENIAC, foi um grande avanço em pouco tempo. Na época, personagens como Steve Jobs, Bill Gates, Steve Wozniak e outros apareceram. Tratava-se de jovens que conheciam eletrônica e perceberam a capacidade que os computadores poderiam exercer na sociedade e nas pessoas.
Como um computador é organizado internamente?
Muito bem, um estudo introdutório de programação não pode deixar de abordar a plataforma onde ele vai ser utilizado. O hardware é o parceiro do software, por isso, vamos estudar a organização básica de computadores, ou seja, vamos ver como ele é por dentro. Assim como qualquer equipamento moderno como a TV, o telefone, o automóvel e outros, o computador é fruto direto da evolução tecnológica das últimas décadas. É claro que em 1940, quando apareceu o primeiro computador, a tecnologia não era como hoje. Naquela época, mal tínhamos a telefonia como conhecemos hoje, imagine um computador. A história dos computadores é dividida em gerações, e vamos dar uma rápida olhada em cada uma delas:
Primeira Geração: 1943 - A primeira geração dos computadores foi marcada pelo ENIAC (Electrical Numerical Integrator and Calculator). Ele foi criado em 1943 por John Eckert e John Mauchly e era bem diferente do que conhecemos por um computador atual.
Segunda Geração: 1947 - A segunda geração dos computadores ficou marcada pelo desenvolvimento do transístor em 1947.Os transístores oferecem muitas vantagens em relação às válvulas:
São muito menores que as válvulas;
Muito mais econômicos;
Muito mais rápidos;
Não esquentam.
Primeira Geração: 1951 - Em 1951, foi criado o UNIVAC (Universal Automatic Computer). Os computadores desta época eram diferentes dos atuais em vários sentidos. Um deles é que os computadores eram construídos com finalidades muito específicas.
Terceira Geração: Período de 1965 a 1970 - Outro grande avanço na eletrônica contribuiu diretamente na arquitetura dos computadores: o surgimento do circuito integrado (CI), também chamado de microchip.
Quarta Geração: Começo da década de 1970 - Os computadores ficam menores ainda e começam a usar o microprocessador, que é um circuito com vários circuitos eletrônicos presentes internamente.
Dias atuais: Depois da quarta geração, os computadores tiveram uma evolução muito rápida. Vamos saber mais sobre a tecnologia nos dias atuais a seguir.
Dias atuais
Depois da quarta geração, os computadores tiveram uma evolução muito rápida. Assim como a tecnologia evoluiu em outras áreas, o computador seguiu esta evolução. Porém, mesmo com os computadores modernos que temos hoje, ultrabooks, tablets, surfaces e outros, sua arquitetura interna não foi tão modificada assim.
Comentário
Essa arquitetura foi criada por John Von Neumann, um matemático húngaro naturalizado estadunidense que contribuiu com várias áreas, inclusive a computação. A arquitetura desenvolvida por ele é usada de uma maneira geral nos computadores mais modernos, inclusive em supercomputadores, com algumas variações, mas de qualquer forma obedecem ao princípio desenvolvido por Von Neumann.
A arquitetura tem o seguinte diagrama. Von Neumann sugeriu uma forma de organizar o computador por meio dos seguintes elementos:
Uma memória, dividida em primária e secundária: A memória primária é o que conhecemos como RAM: memória de acesso aleatório, podendo ser escrita e apagada.
Uma unidade de controle: Responsável pela sincronização entre os demais componentes.
Uma unidade lógica e aritmética (ALU): Responsável pelos cálculos e seus controles.
Dispositivos de entrada e saída: Compreendendo os discos, pendrives e demais dispositivos de armazenamento.
Aula 2
Introdução
Você sabia que vários softwares que usamos são feitos em C++? O Windows é um exemplo, assim como o Autocad, o Photoshop, os jogos da série Half-Life (e muitos outros que você conhece), o MAC OS e vários outros. Portanto, aprender C++ é uma forma de entender o quanto esses softwares de grande porte são complexos e bem-bolados.
O que é um programa?
Um programa nada mais é do que uma sequência de comandos ou ordens dados a um computador. Mas é bem difícil pegar um microfone e dar ordens verbais para um computador realizar o que queremos. O que temos é o nosso teclado e o monitor, por enquanto. Então, um programa é um arquivo de texto, feito no mais simples editor de texto que você possuir no seu computador.
Compilação
Por outro lado, o computador não entende o conteúdo do arquivo de texto contendo o seu programa. Ele precisa ser convertido em uma linguagem que o computador entende, para poder executar o programa. Este processo é chamado de compilação. A compilação ocorre basicamente de acordo com o diagrama:
Existem outras etapas e fases com muitos detalhes, mas basicamente o que precisamos saber é que um programa começa com o seu código-fonte, escrito em umalinguagem de alto nível, e passa por algumas etapas específicas para cada plataforma. Veja que no diagrama o mesmo programa pode rodar no Linux, no Windows ou no Mac, desde que ele seja compilado para estas plataformas.
Saiba mais
Dizemos que uma linguagem é de alto nível quando conseguimos ler e escrever usando palavras conhecidas por nós. O C++, por mais que pareça difícil, possui muitas palavras que nós entendemos, como if (se), while (enquanto), for (para) etc. Portanto, compilar um programa significa converter um arquivo de texto escrito em uma linguagem de programação em códigos binários pertencentes a uma plataforma de execução. Lembre-se: o computador é uma máquina que só entende a linguagem binária. E devido à forma como os sistemas operacionais são construídos, cada um tem suas peculiaridades. Vamos supor que a seguinte sequência signifique: “Escreva ‘alô’ na tela” no Linux: 0111010000100010101. No Mac Os e no Windows, essa sequência pode não significar a mesma coisa; por isso, cada uma das plataformas tem o seu próprio compilador. 
Nosso primeiro programa
Vamos começar com um exemplo bem simples. Em muitos livros, tutoriais, vídeoaulas e afins, o pessoal costuma criar um programa com a mensagem “Alô, mundo”. Nosso caso é mais interessante: vamos calcular a média de um aluno baseado em suas 4 notas bimestrais. A seguir, mostramos um programa completo em C++. Dê uma olhada nele. Será que, mesmo sem saber programar, você consegue adivinhar o que ele faz? Embora já tenhamos adiantado, leia o programa desde o começo, tente traduzir as palavras em inglês e verifique a expressão matemática existente na linha 13.
Iniciando o programa
Complicado? Nem tanto.
Lembre-se que aprender uma linguagem de programação é como aprender um idioma: precisamos conhecer a estrutura da linguagem, sua sintaxe, suas regras e até mesmo suas “manhas”. Vamos estudá-lo linha a linha.
Nosso primeiro programa – Segundo passo
As próximas linhas são parecidas:
float nota1;
float nota2;
float nota3;
float nota4;
float media;
Vamos por partes! O que você acha que significa float?
Float significa flutuar, e como estamos lidando com notas (nota1, nota2, nota3, nota4 e média), isto nos faz pensar que são números de ponto flutuante (ou números com casas decimais). Afinal, uma nota de um aluno pode variar de 0 a 10 e ter casas decimais (7.5, 8.25 etc.), certo?
Então, as linhas de 2 a 6 servem para dizer ao compilador que vamos usar 4 palavras para representar as notas e 1 para a média. O bom é que podemos usar qualquer palavra para essa representação. Poderíamos ter usado, por exemplo, n1 no lugar de nota1, a2 para nota2 etc., só que teríamos um problema: elas não iam fazer muito sentido para quem lesse o programa depois. Porém, a palavra float não pode ser mudada. Ela faz parte de um conjunto próprio da linguagem C++ chamado de palavras reservadas, e não podemos usar palavras que estejam neste conjunto. Para você ter uma ideia, as palavras reservadas em C++ são:
Nosso primeiro programa – terceiro passo
Continuando... As próximas linhas deixam claro que as palavras que criamos antes, nota1 a nota4, vão receber alguns valores.
nota1 = 7;
nota2 = 6;
nota3 = 9;
nota4 = 5;
Se fosse um caso real, no boletim desse suposto aluno, ele teria tirado estas 4 notas. Mas agora temos uma pergunta: “E se fosse outro aluno, como o programa seria?”.
A linha 13 faz o cálculo da média das notas: 
13 media = (nota1+nota2+nota3+nota4)/4;
Porém, ela só faz o cálculo. O resultado não é mostrado na tela.
Reflexão
Como cada aluno tem uma nota diferente, temos que esta nota é um valor variável, ou seja, varia de acordo com o aluno. Logo, o nome destas palavras que usamos é “variável”, e este é um conceito que existe em qualquer linguagem de programação. Então, a resposta é: para que o programa possa aceitar outros valores para as variáveis, precisamos de alguma forma realizar entradas de dados para obter os valores do usuário. Vamos ver isso mais à frente.
Nosso primeiro programa – Quarto passo
As duas linhas seguintes terminam o programa: Nos nossos programas, sempre termine com o comando da linha 15. Vamos estudar o motivo de ele estar aí em outra aula. A linha 16 também é muito importante. Ela fecha o bloco de programa aberto na linha 1. Em C++, você tem que ser educado: se você abre uma porta, tem que fechar; se você abre uma chave “{“, tem que fechá-la: “}”.
Nosso primeiro programa – quinto passo
Neste momento, você pode estar pensando sobre o programa:
Exatamente. Não tem ainda. Nosso objetivo aqui foi estudar um programa do início ao fim, e o programa cumpre o que promete. Vamos estudar sobre entradas e saídas de dados mais adiante. Para você entender um pouco mais, poderíamos inserir na linha 14 o seguinte comando: 
14 cout<<”O valor da media eh: “<
Em C++, o comando que exibe uma mensagem na tela, ou seja, faz a saída de dados, é o cout. Observe que na linha 14, após o comando cout, temos o operador “<<”. Tudo o que vier após o “<<” será impresso na tela. No caso da linha citada, será impresso a string (Dizemos que uma string é uma sequência de caracteres. ‘1’, ‘2’,’a’ etc., são caracteres, e quando os juntamos para formar uma frase como “Olá, mundo”, temos uma string. É sempre representada entre aspas) 
Pontos importantes
Após verificar como o programa funciona, lembre de alguns pontos:
Abriu? Feche! Em todas as linguagens de programação, alguns comandos precisam de caracteres que iniciam outra expressão ou bloco de informações ou comandos. É o caso dos caracteres (, [, {, “, ‘e, dependendo da linguagem, outros ainda são necessários, como < e >. Observe que, toda vez que você abre um parêntese, ele precisa ser fechado; idem para as aspas, chaves, colchetes etc. Nas linguagens de programação, isto não é diferente.
Todas as variáveis em C++ precisam ser declaradas. No nosso exemplo, antes de fazermos o cálculo da média, tivemos que escrever que seriam usadas 5 variáveis (nota1, nota2, ... , nota4 e média). Se fizéssemos o cálculo da média diretamente, o compilador iria gerar um erro. Portanto, se formos usar 300 variáveis no programa, todas as 300 terão que ser declaradas antes.
“Uma coisa é uma coisa; outra coisa é outra coisa”! Em C++, se você declarar uma variável “nota”, ela será diferente de “Nota”, “NOTA”, nOta” etc. Ou seja, C++ é case sensitive (faz distinção de caracteres maiúsculos e minúsculos).
Inicie os programas com INT MAIN (INT ARGC, CHAR** ARGV) { e termine com return 0. Existe um motivo para isso, e cada palavra destes comandos tem um significado e um sentido. Mas vamos estudar sobre isto em outra aula.
Use as endentações, linhas brancas e comentários. Eles servem para deixar o código mais legível e fácil de ser entendido. Pense sempre na manutenção! Não é porque um programa é executado com sucesso que está tudo finalizado. A manutenção posterior de programas é um assunto importante, e um bom programador vai se preocupar com isso. Os comentários são delimitados por /* */ ou ainda //.
Basicamente, a estrutura de um programa em C++ é assim:
Entrada e saída de dados
Todo algoritmo ou programa tem um objetivo. Este objetivo é alcançado por meio de uma entrada de dados, a qual será processada e resultará em uma saída que será avaliada. O problema é que, se a entrada for ruim, serão processados da maneira correta e a saída será ruim (e a culpa cairá sobre o sistema, ou o computador, como sempre!). Portanto, fazer a correta entrada de dados é fundamental. O processo de entrada-processamento-saída ocorre o tempo todo. Todo fluxograma obedece a esse processo; assim como os processos de compilação e de execução. A entrada e a saída podem ocorrer de diversas formas em um computador. Podemos ter a leitura de um cartão de banco em um caixa eletrônico, a digitação da senha, a informação que a senha digitada foi errada como saída e várias outras formas. Portanto, toda vez que for escrever um programa, lembre-se desse trio: entrada-processamento-saída.
Finalizando
Por enquanto,é só. Mas antes de finalizarmos completamente, o que acontece se os valores das variáveis mudarem? Como podemos ver o resultado? Pense nisso e veja nossa atividade proposta em seguida.
Aula 3
Introdução
Existem várias formas de aprender programação. Uma delas é usar o nosso conhecido editor de textos e fazer a compilação “na unha”, ou seja, executar o compilador na linha de comando e acompanhar os resultados gerados. Outra forma é usar os softwares conhecidos como IDE (integrated development environment ou ambiente de desenvolvimento integrado), que facilitam bastante o nosso trabalho. A linguagem C++ possui vários IDEs diferentes, cada um com sua particularidade. Vamos estudar nesta aula o DevC++, que é o nosso escolhido para nos acompanhar durante o aprendizado da linguagem C++. Trata-se de um software muito popular e largamente usado por quem trabalha com C++.
Next, next, finish!
O DevC++ é um software muito popular e fácil de ser encontrado na internet. Ele possui código aberto e, por isso, pode ser baixado gratuitamente e usado sem restrição. Porém, ele só possui versão para Windows.
Fazer a instalação do programa é muito simples, por isso nem compensa tratarmos aqui. Assim como o nome desta seção diz, basta seguir as instruções da tela e clicar em Next, Next e Finish! 
O que é uma IDE?
No mercado de programas de desenvolvimento, encontramos vários softwares chamados de IDE. Estes softwares têm a função de colocar e integrar, em um mesmo ambiente, vários outros programas que ajudam um programador a criar seus programas. Vamos comparar com o Microsoft Word. 
Ele é um editor de texto, certo?
Mas o Notepad, ou mesmo o Wordpad, que vem com o Windows, também são editores de texto.
E por que a maioria das pessoas prefere o Word?
Porque ele possui outros recursos como editores de equação, mala direta, tabelas, etc., que não estão presentes no Wordpad. Ou seja, o Word é um programa composto de outros que o tornam poderoso suficiente para ser o preferido de quem edita texto. A IDE é parecida.
Há alguns anos, quando o Windows ainda nem era sistema operacional, para que um programa C++ fosse compilado, era preciso que o programador possuísse na máquina um compilador e outro programa chamado Linker, para poder gerar o programa executável.
Para quem está acostumado, é fácil, mas para nós que estamos aprendendo, nada melhor que uma tela gráfica, não é?
Portanto, a IDE é um conjunto de programas úteis ao programador reunidos em um mesmo ambiente, a fim de facilitar o trabalho de desenvolvimento.
Exemplo
Entre as IDE mais comuns e gratuitas para o desenvolvimento em C++, temos o DevC++, o Eclipse, o Netbeans, o Codeblocks e o CodeLite. Entre as pagas, temos o Visual Studio, o CLion e o C++Builder. Todas elas podem ser usadas para o desenvolvimento de sistemas de qualquer porte, porém algumas delas têm programas de trabalho em equipe, que as “menores” não possuem. Alguns IDEs possuem ferramentas de testes, distribuição e de refatoração (Melhorar o código por meio da construção de um código mais eficiente, sem abalar a estrutura geral do programa e geralmente contando com a colaboração de outros membros da equipe). Para os programadores mais experientes, isto é muito bom.
Criando nossos programas
Assim como vários outros IDEs, o DevC++ trabalha com um tipo de arquivo chamado de projeto. Um projeto é um agregador de recursos, ou seja, quando desenvolvemos um software, além dos arquivos de código-fonte, podemos ter imagens, bibliotecas de terceiros que podemos incluir no nosso programa, arquivos de configuração e outros. Para criarmos nossos programas em C++, vamos criar um projeto em primeiro lugar. Fazer isto é muito fácil, como podemos ver no vídeo a seguir: Como vimos, basta clicar em Arquivo> Novo> Projeto. Quando a tela “Novo projeto” é mostrada, precisamos configurar o projeto que está sendo criado.
Atividade Proposta
Agora é hora de digitar! Pegue o programa usado na aula 2 e vamos digitá-lo usando o DevC++. O resultado final ficará assim:
Olha que legal! Assim como acontece com outras IDEs existentes, o DevC++ pinta o código de acordo com o tipo de comando ou instrução que está sendo trabalhado. As strings ficam em azul, as palavras-chave ficam em negrito, as diretivas ficam em verde e assim por diante. Além disso, experimente colocar o cursor sobre um } ou ). Ele vai pintar o caractere de vermelho e indicar seu correspondente em negrito. Isto é muito útil.
Observe que temos três opções principais abaixo do menu Executar:
Compilar - Esta opção apenas compila o programa. Em um programa novo, esta opção é obrigatória e inicial. Sem ela, a execução não é possível. Muitas vezes, durante o desenvolvimento do programa, é necessário somente compilar o programa sem precisar necessariamente executá-lo. Neste caso, esta opção é interessante e muito útil.
Executar - Esta opção executa o programa previamente compilado. Em programas pequenos, a etapa de compilação é muito rápida. Já em programas grandes, a compilação pode levar vários minutos. Quando a compilação já foi executada com sucesso, usar a opção para somente executar o programa pode ser bem útil.
Compilar e Executar - Esta opção é útil nas situações em que o programador precisa compilar e logo em seguida executar o programa.
Novo programa
Vamos mudar o programa.
Lembra o programa proposto na aula 2 para transformar graus Celsius em Fahrenheit? Observe-o atentamente!
Vamos digitá-lo no DevC++. 
Compilação e execução
Você percebeu que o programa contém um erro, certo? Ou seja, o programa anterior não será compilado nem executado. E qual é o erro? Observe que o DevC++ é bem camarada e nos indica qual é a linha onde o compilador não conseguiu transformar o código-fonte em código objeto. No exemplo, a variável c não foi declarada. O programador esqueceu que nomeou a variável para os graus Celsius como celsius e não como c.
Saiba mais
Lembre-se: sempre salve o programa antes de compilar novamente. Senão, as alterações que você fez não serão verificadas pelo compilador. O programa correto está aqui:
#include <iostream>
using namespace std;
int main(int argc, char** argv) {
float celsius;
float fahrenheit;
celsius = 25;
fahrenheit = celsius*1.8 + 32;
cout<<celsius<<" graus Celsius equivale a "<<fahrenheit<<" graus Fahrenheit. ";
}
Cin e cout
Antes de continuar, você deve ter notado o cout. E já deve ter percebido que ele é o responsável por exibir algo na tela. Olhando o nosso exemplo, percebemos que a linha a seguir imprime aquela parte na qual o computador “conversa” com o usuário, ou seja, escreve uma frase obtida pelo processamento de algum comando. Veja o exemplo.
Depurando o programa
Já vimos as opções mais básicas de operação do DevC++. Existem muito mais, mas vamos nos concentrar nesse momento em como usar o Dev para nos ajudar a criar e executar os programas.
A depuração é uma atividade que permite ao programador executar o programa passo a passo. Desta forma, ele pode verificar os valores das variáveis e descobrir qual é a execução natural de um programa.
Nesse programa, a depuração é muito tranquila, porque é um programa sequencial. Nos programas que possuem desvios condicionais e repetições, o depurador realmente fará diferença e te mostrará o quanto ele pode ser útil durante o desenvolvimento de um programa. Para começar, vamos inserir um breakpoint. Breakpoint é um ponto de parada, ou seja, após o compilador ter feito a sua parte, o depurador entrará em execução e rodará o programa até a linha que tem o breakpoint. Esta linha (que contém o breakpoint) estará marcada em vermelho.
Comentario
Como vimos, para criar um breakpoint, podemos usar o mouse, clicando na linha desejada, ou usar o menu Executar, ou ainda usar a tecla F4.
Uma vez criado o breakpoint, é hora de executar o programa. Porém, lembre-se que agora a execução ficará parada na linha do breakpoint. Um detalhe: você pode criar quantos breakpoints quiser, porém quando o programa começar, obviamente ele ficará parado no primeirodeles. Nosso objetivo nessa depuração será apenas verificar os valores das variáveis Celsius e Fahrenheit.
Comentario
Viu como é fácil? Para observar os valores das variáveis durante a execução do programa, basta criar marcadores para cada uma das variáveis que deseja observar. Você pode criar quantos marcadores quiser e pode criar expressões matemáticas envolvendo marcadores também.
Depurador
Durante a depuração, a tela do DevC++ passa por uma pequena transformação. A parte inferior da tela muda para o modo Depurador. Neste modo, aparecem alguns botões diferentes:
Veja a seguir a transformação ocorrida.
A parte inferior da tela muda para o modo Depurador. Neste modo, aparecem alguns botões diferentes:
Depurar - serve para iniciar a depuração do programa;
Adicionar Marcador - serve para criar observadores durante a execução do programa;
Próxima Linha - serve para fazer com que o depurador passe para a próxima linha;
Continuar - serve para parar a depuração e continuar a execução do programa normalmente até encontrar o próximo breakpoint;
Próxima Instrução - serve para indicar o depurador e passar para a próxima instrução do programa;
Parar Execução - interrompe o programa e volta para o modo de edição;
Visualizar Janela da CPU - em programas maiores, às vezes é necessário verificar o estado da CPU e de seus registradores. Este botão abre uma janela para mostrar o status da CPU;
Passar por Dentro - este botão terá um maior significado quando estudarmos as funções. Ele permite que o depurador entre no código de uma função quando encontrar uma;
Pular Função - funciona ao contrário do botão anterior. Ao encontrar uma função, o depurador não entrará nela. Ele vai pular a função e passar para a próxima linha.
Comentário
Esses foram os principais tópicos a respeito da depuração. Como já dissemos, é muito importante e benéfico para o seu programa fazer a depuração do código. Desta forma, o programa poderá ser mais bem avaliado, pois erros não visíveis podem ser percebidos. Além disso, trata-se de uma boa prática de programação.
Alguns recursos do DEVC++
O DevC++ possui outros vários recursos que auxiliam o programador. Entre eles, temos:
As propriedades do projeto: menu arquivo-propriedade
Configuração do ambiente
Nesta tela podem ser configuradas várias opções como por exemplo criar arquivos de backup automaticamente, mudar o tema (aparência) do DevC++, entre outras.
Opções do editor
Esta tela é muito útil. Ela configura o comportamento do DevC++ em várias situações, como por exemplo, a autoendentação, posições do cursor etc.
Podem parecer configurações insignificantes, mas no dia a dia do trabalho de programação, esses pequenos ajustes ajudam demais o programador a se tornar mais produtivo.
Finalizando
Basicamente é assim que o DevC++ funciona. Com o que vimos aqui, já é suficiente para você editar os seus programas, compilá-los e fazer a devida investigação de erros por meio do depurador. Além disso, conte com a internet. Devido ao fato de o DevC++ ser muito popular, não falta material sobre ele.
Aula 4
Introdução
Esta aula vai mostrar os operadores aritméticos e os tipos de dados que podemos usar. Você também vai entender como funcionam a entrada e a saída em C++.
Tipos primitivos
Vamos começar a nossa aula com um assunto presente em todas as linguagens de programação: os tipos primitivos.
O que é isso?
Vamos responder com um exemplo. Imagine que você está navegando na internet e chega a um cadastro como este ao lado.
Observe que você tem de preencher campos como: nome, data de nascimento, e-mail, sexo, telefone, identidade, entre outros. Cada cadastro que você encontrar como exemplo na internet possui campos iguais ou semelhantes a esse.
CAMPO “SEXO”
Quais são os possíveis valores que ele pode assumir de acordo com o formulário? Masculino ou feminino, correto?
E provavelmente, no banco de dados, dentro do sistema, ele ficará armazenado como “m” ou “f”. Ou seja, na definição desse formulário, haverá uma variável chamada sexo, a qual poderá guardar apenas dois valores: “m” ou “f”.
São caracteres! Logo, a variável sexo não poderá receber valores como “1”, “verdadeiro”, “3.14159266” etc. Somente poderá receber caracteres.
“Será que existe em C++ um tipo para somente caracteres? Tem. E é chamado de char.
E para o campo nome? Poderíamos usar o char? O tipo char tem uma característica: ele guarda apenas um caractere. Logo, o nome “Matusalém” não poderá ser um valor possível para uma variável do tipo char.
E agora? Bem, já vimos anteriormente que, quando temos vários caracteres juntos, isso é chamado de string.
Temos o tipo string em C++? Não. No caso de C++, para guardar uma string, temos que importar uma biblioteca chamada string. É o mesmo que ocorre com o cout. Lembra que temos de importar a biblioteca iostream para o cout? No caso da string, a biblioteca é a string!
Mas como vou saber isso? Estude a API da linguagem! Lembre-se: a API (application program interface) é o local onde você vai encontrar os recursos disponíveis com toda a documentação para a linguagem que você está usando para programar.
E o campo DDD? É uma variável que não pode aceitar letras, nem símbolos especiais, apenas números. Para isso temos o tipo int (inteiro).”
Será que existe em C++ um tipo para somente caracteres?
No exemplo do formulário, por se tratar de uma ficha de inscrição para o Vestibular, não temos campo como altura ou peso, que também são números, mas podem ter valores decimais. Para este caso, usamos o já conhecido float. Em C++, temos os seguintes tipos básicos de variáveis:
Temos algumas variações desses tipos, que usam os seguintes modificadores de tipos:
Entenda o que é o domínio estendido e as precisões de cada tipo em C++ na tabela a seguir:
Declaração e inicialização de variáveis
Em C++, é obrigatório que toda variável usada no programa seja declarada. A declaração reserva o espaço em memória necessário para a alocação do conteúdo que receberá. A sintaxe da declaração de variáveis em C++ é:
Atenção
Existem algumas regras para a escolha dos nomes de variáveis em C++:
Nomes de variáveis só podem conter letras, números e o caractere “_”;
Não podem começar com um número;
Embora seja possível ter uma variável com o nome “_var” (começando com “_”), estes são reservados para a implementação interna do programa, e seu uso é bem restrito e desaconselhado. O compilador não vai mostrar erro quando criamos variáveis desse jeito, mas o programa criado se comportará de forma inesperada;
Não é possível utilizar palavras reservadas da linguagem C++. Vamos listar as palavras reservadas em seguida;
Também não é possível criar uma variável que tenha o mesmo nome de uma função, mesmo que essa função tenha sido criada pelo programador ou que seja uma função de biblioteca;
Não há limite para o tamanho de nome de variável em C++;Quando criarmos constantes, estas devem ser escritas com todas as letras em maiúsculas.
Portanto, as declarações de variáveis a seguir são válidas: int a;char a, b, c;unsigned int x1, x2, media;char _a;
Lendo e escrevendo em C++
Já vimos rapidamente como é o comando de saída de dados em C++, certo? Agora, vamos tratar um pouco mais profundamente deste assunto. É muito importante criar formas de orientar o usuário com relação ao que o programa necessita para poder funcionar adequadamente. Ou seja, é importante mostrar mensagens na tela e receber informações do usuário de maneira eficiente. Em C++, o comando que exibe uma mensagem na tela, ou seja, que faz a saída de dados, é o cout. Para esse comando funcionar, vimos que é necessário inserir duas linhas no início dos nossos programas:
“Seria mais trabalhoso, certo? Então, para escrevermos algo na tela, usaremos o cout. Veja alguns exemplos:
Observe que tudo que estiver entre aspas, e após o operador <<, será impresso na tela. O comando endl no final do comando faz com que o compilador imprima a string na tela e depois posicione o cursor na linha seguinte. Outro detalheque percebemos na tabela é que podemos combinar expressões curtas com a string entre aspas. Isto é muito comum, principalmente em programas que mostram resultados de operações ou cálculos feitos durante o programa. Esta foi a saída. A entrada de dados em C++ pode ser feita com cin. O cin faz a leitura de dados para serem armazenados em variáveis. Veja o exemplo a seguir, extraído de um programa que calcula a média final de um aluno:
cout<<"Digite a primeira nota: "<<endl;
cin>>nota1;
cout<<"Digite a segunda nota: "<<endl;
cin>>nota2;
cout<<"Digite a terceira nota: "<<endl;
cin>>nota3;
cout<<"Digite a quarta nota: "<<endl;
cin>>nota4;
A parte legal do exemplo é que ele mescla comandos cin e cout. Neste caso, as variáveis nota1, nota2, nota3 e nota4 devem ser previamente declaradas. O cin usa o operador >>. O que for colocado após este operador será atribuído na variável usada.”
O código do programa mostrado no vídeo é:
include
#include
using namespace std;
int main(void){
string nome;
cout<<"Qual eh o seu nome?"<cin>>nome;
cout<<"Oi "<return 0;
}
Saiba mais
Vimos que o vídeo mostra o resultado do valor lido na variável nome. Perceba que no código estamos usando duas diretivas para o compilador (nas linhas 1 e 2). Uma carrega a biblioteca para os comandos cin e cout, e a outra carrega a biblioteca para o tipo string. No vídeo, o valor que é armazenado na variável nome é exibido juntamente com a string “Oi _____, tudo bem com você?”.
Bem, por enquanto é isso sobre entrada e saída. Simples, né? O cin e cout são bem eficientes e você vai notar que eles são bastante usados em C++ e aparecem na maioria das referências que vamos encontrar sobre a linguagem. É claro que a linguagem oferece outros comandos para escrever e ler informações, mas o cin e cout já dão conta muito bem do recado.
Operadores aritméticos em C++
Toda linguagem de programação possui capacidade para fazer contas aritméticas, e com o C++ não é diferente. Na programação de computadores, é possível fazer vários tipos de operações, além das aritméticas. É preciso conhecer o que são operações lógicas, relacionais e outros detalhes para poder construir programas. Temos os seguintes operadores aritméticos em C++. Com eles, podemos fazer as contas mais comuns:
Funções do C++
Certo, já vimos que existem operadores na linguagem.
Mas o que acontece quando precisamos de operações um pouco mais complexas como o cálculo de senos, cossenos, raiz quadrada? Fazer isto em C++?
Assim como outras linguagens de programação, o C++ possui funções que auxiliam o programador em algumas tarefas. Da mesma forma que usamos bibliotecas para as strings e para o cin e cout, podemos usar outras bibliotecas para as funções matemáticas. Uma destas bibliotecas é a cmath. Com ela, podemos calcular a raiz quadrada, por exemplo.
Observe este programa:
SQRT é a forma mnemônica de square root em inglês. Vamos estudar as funções em C++ algumas aulas mais à frente. Novamente você pode perguntar:
“Como eu vou saber em qual biblioteca tem o que eu preciso?”. Lembra-se da resposta?
A resposta é “estude a API”. Não tem jeito; é muito importante estudar a API da linguagem que você está aprendendo.
Operadores lógicos
Como já dissemos, na programação existem operações que não são só aritméticas. Em muitos e muitos casos, precisamos criar situações de comparação entre valores, e essa comparação faz parte de um tipo de operação chamada de operação lógica. Esse tipo de operação faz parte de uma lógica chamada proposicional e foi muito estudada por um matemático chamado George Boole. Assim, também ganhou o nome de “álgebra booleana”.
Essa álgebra trabalha principalmente com valores booleanos ou lógicos, e basicamente nesta lógica só existem dois valores: verdadeiro (true) ou falso (false).
Tudo que conhecemos na computação atual é baseada nessa álgebra. Ela possui propriedades, teoremas e um monte de coisas que excedem o nosso contexto. Mas saiba que ela é muito importante na computação atual. Aliás, quando trabalhamos com a aritmética binária, de certa forma, também estamos trabalhando com a álgebra de Boole, e neste caso normalmente usamos 0 para valores falsos e 1 para verdadeiros. Na álgebra de Boole, temos basicamente três operadores:
Na álgebra booleana, usamos um recurso chamado de tabela verdade para mostrar os valores possíveis que as variáveis lógicas podem assumir. A tabela verdade mostra todas as possibilidades combinatórias entre os valores de diversas variáveis lógicas que são encontradas em somente duas situações e um conjunto de operadores lógicos. Nas tabelas verdade a seguir, A e B são proposições. Os operadores lógicos “e” e “ou” em C++ são representados pelos símbolos “&&” e “||” respectivamente. Veja suas tabelas verdades:
Guarde essas informações, pois vamos fazer um exemplo mais completo adiante.
Saiba mais
Duas dicas que pode te ajudar nas operações envolvendo condições lógicas:
Em uma expressão envolvendo o operador E (&&), a expressão só será verdadeira se todas as partes da expressão forem verdadeiras. Se contiver uma só que seja falsa, toda a expressão será falsa;
Em uma expressão envolvendo o operador OU (||), a expressão só será falsa se todas as partes da expressão forem falsas. Se contiver uma só que seja verdadeira, toda a expressão será verdadeira.
Operadores relacionais
Os operadores relacionais são usados para fazer comparações entre dois operandos do mesmo tipo primitivo. Esses valores são representados por constantes, variáveis ou expressões aritméticas.
Vejamos um exemplo. Considere:
a = 1;
b = 2;
c = verdadeiro;
Se fôssemos fazer essas declarações em C++, teríamos: 
int a = 1;
int b = 2;
bool c = true;
bool é um tipo em C++ e pode assumir os valores booleanos true ou false.
Aula 5
Introdução
Tomar decisões é uma parte muito importante da nossa vida e também dos nossos programas. Fazemos isso todos os dias e a toda hora. Um programa também tem momentos nos quais tem de parar e avaliar as condições para tomar uma determinada direção. Imagine o robô Curiosity em Marte fazendo suas explorações: ao encontrar um determinado tipo de material, ele precisa avaliar e tomar alguma decisão. Enfim, a estrutura de decisão é outra peça fundamental e presente em qualquer linguagem de programação. Vamos dividir este conceito em duas aulas e, nesta, vamos começar com os conceitos mais básicos.
Recordando...
Até agora, vimos os seguintes elementos de programação:
Já aprendemos bastante coisa, não é?
Para continuar nossos estudos, temos que começar a aplicar estes conceitos daqui para a frente e estudar alguns comandos que desviam o fluxo sequencial e natural de um algoritmo e de um programa. É assim que ocorre também na estrada a seguir: o motorista que está nesta estrada tem uma importante decisão a fazer: ou toma o caminho da direita ou o da esquerda.
Exemplo
Nos programas de computador, as decisões são muito mais comuns do que você pensa. Quando você abre um arquivo, se ele for protegido, então vai aparecer uma janela avisando. No Word, se o botão de negrito estiver selecionado, então o seu texto ficará em negrito, e por aí vai. Temos que aprender a fazer isso. Vamos usar um exemplo mais fácil: pense nas suas notas escolares. Suponha que a média para aprovação seja 6.
Como você bolaria um programa para verificar se você está aprovado ou não?
O desvio é feito quando a média é maior que 6. E uma vez que a média for maior que 6, o programa pega um caminho que exclui a outra possibilidade (de ser menor que 6).Além disso, atente que, se a nota for exatamente igual a 6, nem assim o aluno estará aprovado. Percebeu que a condição lógica é importante? Isto foi visto na aula anterior, e lá dissemos que estas condições têm que ser muito bem montadas para poder executar o programa corretamente.
Esse desvio é chamado de desvio condicional simples. Vamos observá-lo com mais detalhes em C++.
Calculando um desvio condicional simples
Você também deve ter percebido que grifamos algumas palavrasdesde o início desta aula. 
Quais foram as palavras grifadas? “Se” e “então”. Aí, entramos no conceito do primeiro tipo de desvio: o chamado desvio condicional simples.
Vamos fazer um exemplo para mostrar este tipo de desvio de fluxo. Trata-se do cálculo do IMC (Índice de Massa Corporal. Este índice é adotado pela OMS (Organização Mundial de Saúde) e é usado para o diagnóstico da obesidade e sobrepeso) (índice de massa corporal). Este índice é muito fácil de ser calculado e, de acordo com seu resultado, precisamos consultar uma tabela para classificar o usuário.
Como programar um desvio condicional simples
Veja que o programa:
Compare a forma como usamos o if com a figura do comando exibida anteriormente. Tranquilo, né? Se o cálculo for menor que 17, o sujeito está bem abaixo do peso. Essa classificação é feita de acordo com a tabela a seguir. Esta tabela pode ser obtida em qualquer site que mostre o cálculo do IMC.
Programando...
Portanto, como podemos perceber, a sintaxe de um if em C++ é assim:
Perceba que temos alguns detalhes que precisam ser seguidos para o if poder funcionar.
Exemplo
Em C++, não utilizamos a palavra “então”. Fica implícito que o código que virá a seguir é o que deve ser feito quando a condição testada é verdadeira. O comando é simples. Dentro dos parênteses há um teste, o qual pode ser uma simples comparação ou uma expressão lógica maior. Isto vai depender do programa.
Então, prepare-se para colocar dentro desse teste qualquer tipo de expressão que possa ser avaliada e retornar verdadeiro (true) ou falso (false). Se o teste for verdadeiro, o bloco é executado. Se for falso, o bloco é ignorado completamente e o fluxo do programa continua na linha seguinte ao bloco. O tamanho do bloco pode ser de 1, 2, 200, 2.000 linhas. De qualquer forma, se o teste for false, todo o bloco, independentemente do tamanho que seja, será ignorado. 
Você se lembra do fluxograma? Para esta estrutura, o fluxograma correspondente é:
Voltando ao programa do cálculo do IMC, podemos torná-lo mais complexo. Como você pode perceber, o programa só vai tratar daquelas pessoas bem magrinhas. As outras classificações existentes na tabela não foram contempladas.
E agora? Como vamos fazer? O que você sugere?
É simples. Se for menor que 17, já fizemos, a situação é “muito abaixo do peso”. Se estiver entre 17 e 18,49, a situação é “abaixo do peso”. Se estiver entre 18,5 e 24,99, a situação é “peso normal”. E assim por diante. Mas o que significa estar entre 17 e 18,49 (por exemplo)? 
Como programar um desvio condicional composto
Até agora, aprendemos apenas uma parte da estrutura condicional. Vimos que, se uma condição for verdadeira, ela vai executar um bloco de programação, e em seguida, continuar com o fluxo normal do programa. Veja o exemplo:
Observe que se a idade for menor que 18, o programa vai ignorar todo o bloco entre as linhas 10 a 14 e continuar o seu fluxo normal na linha 15.
Mas e se quisermos tratar a condição quando a idade for menor que 18 anos?
Sua primeira resposta pode ser: “mas isto já é feito no programa acima. A linha 15 é executada se a idade for menor que 18”. Preste atenção: a linha 15 será executada de qualquer maneira. 
O que estamos propondo agora é: Se a idade for maior que 18, faça as linhas 11 a 14, senão faça outra coisa! A situação pode ser explicada de acordo com o fluxograma a seguir:
Programando um desvio condicional composto
Em C++, a sintaxe é a seguinte:
Vamos ver um exemplo em C++:
Na linha 10, o teste é feito. Se o número for positivo, o programa executa a linha 11, encontra o fim do bloco e (preste atenção agora) vai para a linha 16. O programa ignora o bloco do “else” (pois este bloco é a execução caso o teste for falso). Se o teste da linha 10 for falso, o programa vai ignorar o bloco que começa com o { logo após o if e vai diretamente procurar o else, que está na linha 13. Ele executa o bloco do else, também passa pela linha 16 e finaliza o programa.
O código do programa executado no vídeo é o seguinte:
Durante o vídeo, temos duas execuções. Cada uma delas mostra o resultado do teste da linha 10. Veja que, quando o teste é positivo, o programa executa o bloco das linhas 10 a 13, e quando o teste é falso, o bloco das linhas 14 a 17 é executado. E para finalizar, a frase da linha 18 é sempre mostrada.
Na próxima aula, vamos continuar a aprender outras formas de desvios de fluxo e, portanto, ainda vamos ficar mais um tempo desvendando o “if-else”. Até lá!
Aula 6
Introdução
Esta é a segunda parte das estruturas de decisão. Na primeira aula, vimos alguns conceitos básicos que são as estruturas iniciais para começarmos a tratar o assunto. Nesta aula, vamos mostrar as outras formas de tomar decisões e suas implementações em C++.Dessa forma, nosso repertório de comandos vai aumentar e você vai conseguir criar programas mais interessantes e completos em C++.
Recapitulando...
No final da última aula, vimos a estrutura condicional de comando composto. Esta estrutura é a famosa “if-then-else”, porque trata o teste condicional de uma maneira completa: “se o teste for verdadeiro, então faça isso, senão faça aquilo”. Ela tem a seguinte forma, como vimos:
Para lembrar a estrutura, observe o exemplo a seguir.
Lembrou?
O teste é feito na linha 10; caso verdadeiro, executa o bloco das linhas 10-12; senão, executa o bloco das linhas 13-15. Observe o teste da linha 10. Usamos o operador %, chamado mod. Este operador retorna como resultado o resto da divisão; no exemplo, do número n por 2. Se for zero, é um número par; senão, é um número ímpar.
Mudando o teste...
Para relaxar, vamos fazer uma brincadeira com C++. Se você quiser impressionar alguém e dizer que conhece bastante de programação, em vez de escrever as linhas 10 a 15, substitua-as apenas pela linha 10 deste código. O resultado é o mesmo que o código anterior.
É uma forma que parece bem complicada, não é? Mas vamos explicar: trata-se de outro operador existente em C++ e em outras linguagens, chamado de operador ternário. Ele é uma alternativa para substituir o desvio condicional composto em algumas situações. Veja sua sintaxe:
Como é um operador ternário, temos três operandos:
Esse operador também é útil quando vamos atribuir um valor a uma variável como resultado de um if.
Observe:
if (x == 10) // Se x for igual a 10 
y = 20; // então faço y receber 20else
y = 30; // senão faço y receber 30 
Usando o operador condicional ternário, poderíamos escrever:
y = (x == 10) ? 20 : 30; // y recebe, se x for igual a 10 então 20, senão 30.
Colocando um if Dentro do Outro
Colocar um if dentro do outro é mais comum do que você imagina. Esta forma é chamada de aninhamento ou encadeamento de ifs e é usada em várias linguagens de programação e também com outros comandos. Vamos nos concentrar nos ifs por enquanto.
Veja que temos um if dentro do outro:
O if que começa na linha 13 vai até a linha 18, quando a condição (idade>=18) for verdadeira.
Dentro deste if, temos um if simples aninhado entre as linhas 16 e 18.
Caso a condição da linha 13 seja falsa, temos o else, que compreende as linhas de 20 a 27.
Dentro do else, temos um if-then-else completo nas linhas 21 a 26.
Como podemos ver, o aninhamento de ifs é muito útil e é mais comum do que pensa. Existem muitas situações que usam estruturas aninhadas, e nas próximas aulas esta estrutura ficará cada vez mais comum, e com outros comandos também.
O Comando Switch
Este comando é bastante útil. Veja um exemplo em que ele pode ser usado: imagine um programa no qual o usuário informa um mês, e o programa devolve se o mês tem 30 ou 31 dias.
Como você faria esse programa?
“Vou ter que ler o número do mês.”
“Se for janeiro, tem 31 dias.”
“Se for fevereiro, pode ter 28 ou 29 dias. Se o ano for bissexto, tem 29; senão, tem 28. Bem, mas acho que desta vez, eu vou considerar que tem 28 dias, só pra facilitar.”
“Se for março, tem 31.”
“Abril tem 30”, “maio tem 31.” 
“se for junho, então são 30...”
“e sefor dezembro, tem 31.” 
“Caramba, vai ser um monte de ifs!”
Se fosse usar o comando if, o programa teria pelo menos 12 ifs. O comando switch facilita a nossa vida. Sua sintaxe é:
switch (variável){
case constante1:
Instruções;
break;
case constante2:
Instruções;
break;
default
Instruções;
}
Veja como o switch seria usado nesse caso:
 #include <iostream>
 using namespace std;
 int main(int argc, char** argv) {
 int mes,dias;
 cout<<"Digite o número do mês:"<<endl;
 cin>>mes;
 switch (mes){
 case 1:
 dias = 31;
 break;
 case 2:
 dias = 28;
 break;
 case 3:
 dias = 31;
 break;
 case 4:
 dias = 30;
 break;
 case 5:
 dias = 31;
 break;
 case 6:
 dias = 30;
 break;
 case 7:
 dias = 30;
 break;
 case 8:
 dias = 31;
 break;
 case 9:
 dias = 30;
 break;
 case 10:
 dias = 31;
 break;
 case 11:
 dias = 30;
 break;
 case 12:
 dias = 31;
46 break;
47 default:
out<<”Você digitou um mês
inválido”<<endl;
 break;
 }
 cout<<"O mês "<<mes<<" tem "<<dias<<" dias.";
 return 0;
 }
Entendeu como este comando funciona? Ele é muito útil e pode ser usado quando temos vários ifs. É interessante usá-lo para substituir vários ifs e deixar o código mais legível. Também é bastante usado em estruturas de menu. Porém, temos uma limitação: o comando não pode ser usado para avaliar expressões relacionais. Ele só funciona quando comparamos com um valor constante e, quando a comparação é verdadeira, um bloco de comandos é executado. No caso do exemplo, a linha a seguir avalia o valor da variável mês e, dependendo do valor, um determinado case será executado:
 switch (mes){
 case 1:
 dias = 31;
 break;
É muito importante usar o comando break após cada bloco de execução do case. O comando break interrompe o switch e o programa volta ao fluxo de execução após o fechamento do comando switch.
Vamos ver o programa em execução
Lembre-se sempre de colocar a cláusula default, como mostram as linhas 47 a 50. Durante o vídeo, você percebeu que foram testados alguns valores corretos para os meses, porém na última execução foi inserido o mês 29 e o programa executou a cláusula default. Imagine se fizéssemos esse programa usando o if. Seriam vários ifs e, além disso, seria difícil ler o programa. O switch é muito bom para deixar o programa mais claro. Porém, a última execução do programa deixou uma “rebarba”. Veja que, se o usuário digitar um mês negativo ou outro valor que não esteja dentro das cláusulas case, o programa executa corretamente a cláusula default, mas imprime na tela a mensagem da linha 51. Seria melhor que essa linha não fosse impressa quando o valor for inválido. E agora? Agora, precisamos de uma forma de criar uma condição lógica. Para isso, entramos no próximo tópico desta aula.
Operadores Lógicos
Em C++, temos três operadores:
No exemplo anterior, precisamos criar uma condição que não deixe que o programa aceite valores abaixo de 1 E acima de 12. Se fosse nas aulas de Matemática, seria fácil: poderíamos criar uma expressão assim:
1<=mês<=12
Mas em C++, precisamos transformar essa condição de acordo com a sintaxe da linguagem.
Aula 7
Introdução
A estrutura de repetição, junto com as estruturas sequenciais e de decisão, forma a trinca de estruturas fundamentais de desenvolvimento em qualquer linguagem de programação. É interessante notar o quanto fazemos tarefas repetidas no dia a dia. Todos os dias acordamos, estudamos, trabalhamos, dormimos etc. Na programação, não é diferente. Jogar um “joguinho” no computador é uma estrutura de repetição, assim como o próprio sistema operacional funciona em uma estrutura de repetição. Existem milhares de exemplos. Vamos começar a estudá-los nesta aula.
Repetições
Vamos a mais uma importante estrutura de programação: a estrutura de repetição.
Chico Buarque diz, na música Cotidiano:
“todo dia ela faz tudo sempre igual, me sacode às seis horas da manhã, me sorri um sorriso pontual”...
Concorda que essa é uma repetição? Repetições infinitas não são muito agradáveis, seja no mundo real ou em programas de computador.
Vamos a um exemplo mais prático. Creio que você sabe jogar o famoso “jogo da velha”, certo?
Olha só como é o jogo:
Pergunto a você:
- Quantas jogadas no máximo podemos ter em um jogo da velha?- Como o jogo começa?
Como termina?
Em breve, você terá condições de criar um jogo da velha bem bacana em C++, sabia? Até lá, essas perguntas deverão estar respondidas. Um jogo como este, ou um jogo de videogame qualquer, é uma estrutura de repetição.
No mundo empresarial, temos milhares de situações envolvendo repetições: o cálculo de uma folha de pagamento, uma linha de produção em uma fábrica, um projeto de desenvolvimento de software etc. Ah, respondendo às perguntas do jogo da velha: Temos no máximo nove jogadas; se o jogador “X” começar, ele terá uma jogada a mais. Idem para o jogador “O”. Isto se o jogo não acabar antes; O jogo termina com todas as posições em branco, esperando ser preenchidas com “X” ou “O”;- O jogo finaliza quando algum dos jogadores ganha ou quando há um empate e ninguém faz uma sequência. Trocando para a linguagem de computador, teríamos:
A palavra repetir é muito importante no exemplo. É ela que vai fazer com que a repetição ocorra nove vezes, que é um número conhecido. A cada repetição, quatro atividades serão feitas (jogada do “X”, verifica se ganhou; jogada do “Y”, verifica se ganhou). Sendo assim, temos nossa primeira forma de fazer repetição em C++.
A Estrutura For
Qual é a tradução de for? 
“Para”, certo? Pois bem, a estrutura for é muito usada nas repetições, principalmente nas ocasiões nas quais sabemos a quantidade de repetições que ocorrerão. Esse tipo de repetição é chamada de repetição controlada por contador, pois teremos uma variável que determinará o número de repetições daquela parte do programa. Observe: é um pouco estranho ter duas repetições e meia, ou “repita 10 vezes e meia”, certo? Logo, esta variável tem que ser inteira. Não podemos ter uma variável decimal para contar quantas repetições teremos.
Exemplo
Vamos a um exemplo em C++:O exemplo mais simples que podemos fazer é criar um programa que conta de 1 a 10.
Veja só:
A execução do programa gera o seguinte resultado:
Simples, não é? Observe a sintaxe do for em C++:for (inicialização ; condição ; incremento)
O comando for em C++ é composto por três partes, e cada uma delas é separada por ponto e vírgula:
Inicialização - declaramos uma variável do tipo inteiro (sempre) e atribuímos um valor inicial;
Condição - é uma expressão relacional que determina quando a repetição acaba. Quando a condição se tornar falsa, a execução do programa continua no comando seguinte ao for;
Incremento - configura como a variável de controle da repetição varia cada vez que a repetição é executada. Pode ser positivo ou negativo.
O for do primeiro exemplo está mostrado na linha 5. Vamos dar uma pausa no for para tratar de um assunto que está bastante relacionado com as estruturas de repetição em geral.
Operador “++” no lugar do incremento i = i+1
Você já deve ter reparado que, no comando for, usamos uma forma de incremento um pouco diferente do normal, certo? Usamos o operador “++” no lugar do incremento i = i+1. Esses operadores possuem um nome: são chamados de operadores unários e podem ser de incremento, o ++, e o de decremento, --. Veja a tabela a seguir:
	Operador
	Nome
	Expressão de exemplo
	Explicação
	++
	Pré-incremento
	++i
	Incrementa i por 1 e depois
usa o novo valor de i na expressão em que i reside
	++
	Pós-incremento
	i++
	Usa o valor atual de i na
expressão que i reside, e
depois incrementa i por 1
	--
	Pré-decremento
	--j
	Decrementa j por 1 e depois usa o novo valor de j na expressão em que j reside
	--
	Pré-excremento
	j--
	Usa o valor atual de j na
expressão em que j reside e
depois decrementa j por 1
Vamos fazer um exemplo para ilustrar o uso desses operadores. Observe atentamente o programa a seguir:
#include <iostream>
 usingnamespace std;
 int main (void){
 int i;
 i=5;
 cout<<i<<endl;
 cout<<i++<<endl;
 cout<<i<<endl;
cout<<"------------
"<<endl;
 i=5;
 cout<<i<<endl;
 cout<<++i<<endl;
 cout<<i<<endl;
 return 0;
 }
A linha 7 inicializa a variável i com o valor 5, o qual é mostrado na linha 8. A linha 9 gera a saída do valor da expressão i++. Esta expressão incrementa a variável, e então, por ser pós-incrementado, o valor 5 é mostrado na tela, e depois o valor de i é incrementado (por isso ser “pós-incrementado”). A linha 10 mostra o novo valor de i e mostra a prova que o valor foi incrementado. A linha 12 serve apenas para dividir o programa. A linha 14 reinicializa o valor da variável i, o qual é mostrado na linha 15. Na linha 16, o valor da expressão ++i é mostrado na tela. Como o operador está na frente da variável i, ela incrementa o i em primeiro lugar e depois o novo valor (6) é mostrado na tela. A linha 17 mostra o valor de i, que ainda é 6, depois que a linha 16 é executada. O resultado do programa está mostrado na figura a seguir:
Tome cuidado com o seguinte: tentar usar o operador de incremento ou de decremento em uma expressão diferente da qual ele foi designado é um erro de sintaxe. Veja o exemplo: ++(x+1) não é permitido, pois (x+1) não é uma variável.
Além disso, o C++ oferece a possibilidade de abreviar expressões de atribuição com os operadores de atribuição compostos. Observe os exemplos: a = a+ 5 é o mesmo que escrever a += 5
O operador += soma o valor da expressão à direita do operador ao valor da variável à esquerda do operador e guarda o resultado na variável à esquerda. Isto pode ser feito também com os operadores -=, *=, /= e %=. Veja alguns exemplos.
Supondo x=4, y=6, z=5, w=7, t=13:
x+=7 -> x = x+7 -> x=11
y-=4 -> y = y-4 -> y=2
z*=5 -> z = z*5 -> z=25
w/=7 -> w = w/7 -> w=1
t%=4 -> t = t%4 -> t=1
O que podemos fazer com o for?
Agora que vimos o que podemos fazer com os operadores em C++, olha só o que podemos fazer com o for:
Alterar a variável de controle de 1 a 100 incrementando de 1for (int i=1; i<=100; i++)
Alterar a variável de controle de 100 a 1 em decrementos de 1for (int i=100; i>=1; i--)
Alterar a variável de controle de 8 a 88 em incrementos de 8for (int i=8; i<=88; i+=8)
Alterar a variável de controle de 20 a 2 em decrementos de 2for (int i=20; i>=2; i-=2)
Alterar a variável de controle sobre uma sequência de valores. Por exemplo: 2,5,8,11,14,17,20for (int i=2; i<=20; i+=3)
Alterar a variável de controle sobre uma sequência de valores. Por exemplo: 99,88,77,66,55,44,33,22,11,0for (int i=99; i>=0; i -=11)
O comando for é usado para várias finalidades, em qualquer linguagem de programação. Uma das aplicações é somar valores. Observe o exemplo a seguir:
A execução do programa gera o seguinte resultado:
Embora o exemplo seja muito simples, ele mostra um uso muito comum desse tipo de estrutura de repetição: usar o for para somar valores e armazenar em uma variável que está dentro da repetição. Vamos fazer outro exemplo, e com ele, ajudar uma criança a aprender a tabuada. A ideia do programa é obter um valor do usuário referente à tabuada que ele deseja estudar e “tomar” a tabuada do número desejado.
A cada repetição, o usuário deve digitar a resposta, e o programa vai acumular a quantidade de erros e acertos que ele tiver durante a execução. Ao final da execução, o programa mostra a quantidade de erros e acertos que o usuário teve. É um programa que envolve vários assuntos que já estudamos. Observe a listagem:
#include <iostream>
 using namespace std;
 int main (void){
 int num,
 resposta,
 acertos=0,
 erros=0;
 cout<<"Digite qual tabuada você quer estudar: ";
 cin>>num;
 for (int i=1; i<=10; i++){
 cout<<num<<" x "<<i<<" = ";
 cin>>resposta;
 if (resposta == (num*i)){
 cout<<" Acertou :-)"<<endl;
 acertos++;
 }
 else {
 cout<<" Errou :-("<<endl;
 erros++;
 } //fim do bloco do for
 if (acertos==10){
 cout<<"Parabéns! Você acertou tudo!"<<endl;
 }
 else {
 cout<<"Você teve "<<acertos<<" acertos e "<<erros<<" erros."<<endl;
 }
 return 0;
 }
Veja a execução do programa:
Como vimos no vídeo e na listagem, o programa cria uma repetição de 1 a 10 entre as linhas 13 a 24. Veja que nem sempre o for faz repetições somente com uma linha, como vimos nos exemplos anteriores. Neste programa e na maioria deles, o bloco de repetição pode ser bem grande. Para cada repetição, o programa pergunta o resultado da multiplicação do número da tabuada e do número da repetição atual. Se o usuário acertar, a variável acertos é acumulada, senão a variável erros é incrementada.
Para isso, usamos uma estrutura de decisão composta (lembra?). Ou seja, misturamos nesse programa a estrutura de repetição com a estrutura de decisão vista anteriormente. No final do programa, nas linhas 25 a 30 é feita uma pequena análise do desempenho do usuário durante o programa. O programa “premia” o usuário que acertou todas as respostas; se houve um erro ou mais, ele mostra a quantidade de erros (de acordo com a variável erros) e a quantidade de acertos (variável acertos). Existem muitas coisas que dá para fazer com o for. Mas por enquanto, para aprender como ele funciona, está ótimo.
Aula 8
Introdução
Existem formas diferentes de se repetir uma atividade. Algumas atividades ficam repetindo, até que ocorra uma determinada situação. Outras que se repetem indefinidamente, outras que sabemos a quantidade de vezes que serão repetidas e variações sobre isso. Nesta aula, vamos ver os outros comandos em C++ que completam as estruturas de repetição e, assim, dar condições para você criar seus programas. Teoricamente, você já terá condições de criar a maioria dos programas com o “repertório” de conhecimento que adquiriu até aqui.
O que vimos e o que veremos
Lá vamos nós de novo às estruturas de repetição! Vimos, na aula passada, que o for tem uma peculiaridade: ele é usado quando sabemos o número de vezes que uma repetição será executada. Mas existem situações nas quais não sabemos o número de repetições. Em outras situações, a repetição deve ocorrer pelo menos uma vez, e dependendo da condição, a repetição será ou não continuada. Vamos investigar esses detalhes. Vamos à primeira situação que estudaremos...
Repetição com Limite do Contador Determinado pelo Usuário
Ao ler o tipo de repetição, já podemos entender o que vai acontecer: a repetição será controlada por um contador determinado pelo usuário. Compare com o for, que você já conhece: embora sejamos nós programadores que digitamos a condição final, naquele momento não estamos desempenhando o papel do usuário, e sim do programador. Agora é diferente: é o usuário que vai determinar isso. Embora dê para fazer esta estrutura com o for, existe outro comando mais interessante para esta tarefa: o while (enquanto). Este comando tem a seguinte sintaxe:
while (){
‹ bloco de comandos ›
}
Esquematicamente, o comando funciona de acordo com o seguinte diagrama:
Veja, no diagrama, que o fluxo chega a uma condição (decisão) no qual será avaliada. Se for verdadeira, o fluxo passa para as instruções a serem executadas e volta à condição. Viu o looping aí? Enquanto a condição for verdadeira, o fluxo ficará “preso” a esse laço. Quando a condição for falsa, aí sim, ele se liberta e continua o programa. Portanto, evite criar condições que deixem o programa preso para sempre no looping, o chamado (e temido) looping infinito. Vamos programar então? Vamos lá!
O exemplo é simples. Já que falamos algumas vezes de folha de pagamento, vamos fazer uma bem simples. O algoritmo consiste em ler do usuário um número de funcionários, que será o nosso contador. Para cada funcionário, será pedido o salário mensal, e este valor será somado ao valor da folha. O código do programa é:
Veja que, na linha 11 até a 16, temos o while sendo controlado por uma variável que o usuário digitou. Se o usuário digitar 800, teremos 800 repetições (800 funcionários); se digitarmos 8, teremos 8 repetições e assim por diante. Alinha 15 é muito importante e muitas vezes é esquecida pelos iniciantes. Sem ela, o looping cairá numa repetição infinita, o que, mais uma vez, é tudo o que não queremos. Nunca se esqueça de colocar dentro de um while a alteração da variável de controle! A cada repetição, a variável valor_folha é incrementada com o valor do salário lido. Veja a linha 14 e olhe o operador += que foi usado. Lembra-se dele, né? Para recordar, ele faz o mesmo que valor_folha = valor_folha + salario. Observe também o operador de incremento na linha 15.
Fizemos uma demonstração com apenas 5 funcionários. No final, vimos o valor da folha de pagamento. É óbvio que uma folha de pagamento real tem, normalmente, mais funcionários e muito mais detalhes. E acredite, com o conhecimento que você tem, já daria para criar um programa para esse processo. Vamos agora continuar estudando o while com uma pequena variação.
Repetição Controlada pelo Resultado de uma Operação
Agora, veremos quando uma repetição não será controlada pelo programador nem pelo usuário, mas o próprio programa. Vamos ver como é isto por meio de um exemplo.
Você sabe o que é MDC?
É o máximo divisor comum. Dois números naturais sempre terão um máximo divisor comum. Por exemplo: os divisores comuns de 12 e 18 são 1, 2, 3 e 6; logo, 6 é o MDC entre 12 e 18, e anotamos assim: MDC (12,18) = 6. Para que serve o MDC?
Exemplo
Veja este exemplo obtido do site Brasil Escola: Uma indústria de tecidos fabrica retalhos de mesmo comprimento. Após realizarem os cortes necessários, verificou-se que duas peças restantes tinham as seguintes medidas: 156 centímetros e 234 centímetros. O gerente de produção, ao ser informado das medidas, deu a ordem para que o funcionário cortasse o pano em partes iguais e de maior comprimento possível. Como ele poderá resolver essa situação? Simples: com o MDC dos números 156 e 234.
Texto padrão:
O programa pede ao usuário que digite os dois números dos quais ele deseja encontrar o MDC. Isto ocorre nas linhas 6 a 8. A novidade ocorre na linha 10. Perceba que temos um comando chamado do, o qual abre um bloco de programação nesta mesma linha, o qual é fechado na linha 15 com o comando while, já nosso conhecido, e com uma condição: (num1>0). Agora, vamos conhecer o comando do-while. O objetivo dele é avaliar uma condição após um bloco de programação. Se a condição for verdadeira, o loop repete; se for falsa, o loop para e prossegue com o fluxo do programa.
A sintaxe do comando é assim:
do {
comando;
comando;
...
} while (condição);
Veja que obrigatoriamente pelo menos uma vez o bloco será executado. Esta é a maior característica dessa estrutura. Voltando ao nosso programa, ele segue um algoritmo chamado de “algoritmo óbvio”, que é derivado de outro algoritmo chamado de “algoritmo de Euclides” (que foi desenvolvido em 300 a.C.). Não vamos explicar agora o algoritmo; isto acontecerá na sua aula de Cálculo, mas essencialmente o algoritmo trabalha com o resto da divisão entre os dois números, que devem ser lidos em ordem crescente. O algoritmo entra em uma repetição, enquanto a repetição deixa a variável num1 positiva. A variável num1 tem o seu valor modificado pelo próprio programa durante a repetição, como se pode ver na linha 14. A linha 12 mostra a execução do programa passo a passo, apenas para informar ao usuário sobre o andamento do programa. Vamos ver o programa em funcionamento e ajudar o dono da fábrica de tecidos a saber qual comprimento do tecido ele deve cortar.
Vamos ver o programa rodando?
Como podemos ver, o dono da fábrica deve cortar dois pedaços de 78 cm. Para esse caso, vimos que o programa executa poucas repetições. Porém, na segunda execução, para os números 317811 e 514229, o programa executa muito mais e não chega a um divisor máximo comum, e portanto, o MDC (317811,514229) = 1. Vimos a repetição controlada pelo usuário, pelo programador e pelo próprio programa. Agora vamos estudar mais uma forma de repetição que pode ser útil em vários programas, principalmente aqueles que apresentam um menu de escolha de opções.
Repetição Controlada pelo Valor da Entrada de Dados
Esta é uma variação da estrutura que vimos usando o for. Com o for, percebemos que ele é adequado para situações em que o número de repetições é bem definido e conhecido. Agora vamos ver uma variação desse tipo de estrutura, porém usando o comando while. Um bom exemplo é o cálculo do pi (π) usando uma série infinita, chamada de série de Gregory-Leibniz. Esta série tem o seguinte formato:
Sabemos que podemos simplificar o valor de pi usando 3,14, mas em várias situações de cálculos trigonométricos ou outros que requerem maior precisão, temos que usar o pi com um número de casas mais significativos.
Atenção
Temos um detalhe: a série de Gregory-Leibniz só funciona bem com no mínimo 500.000 repetições. Você pode pensar que demoraria para retornar o resultado, mas isto vai depender do seu computador. Se o seu computador tiver um bom processador, com bastante memória RAM, em pouquíssimos segundos o resultado irá aparecer. Estávamos acostumados com poucas repetições, certo? Agora apareceu um programa mais exigente!
Uma vez estabelecido o algoritmo, veja aqui uma possível solução para o problema em C++.
Uma vez que você tenha estabelecido o algoritmo, uma possível solução para o problema em C++ é:
#include <iostream>
 using namespace std;
 int main (void){
 int num_termos,contador=1;
 double pi=0,i=1.0;
 cout<<"Quantos termos você deseja?"<<endl;
 cin>>num_termos;
 while (contador<=num_termos){
 pi += 4/i;
 i+=2;
 pi -= 4/i;
 contador++;
 i+=2;
 }
cout<<"O valor de PI com "<<num_termos<<" termos ="<<pi<<endl;
 return 0;
 }
Veja que, na listagem, mais uma vez aparecem os operadores de incremento nas linhas 12, 13, 14,15 e 16. Nós avisamos na aula passada que eles seriam bastante usados, não é? Observe também a linha 11, na qual aparece o operador relacional <=. O looping ocorre entre as linhas 11 e 17. Veja que, na condição, a variável num_termos foi informada pelo usuário e é a condição de parada da repetição. Na linha 15, aparece o incremento da variável contador. Mais uma vez, vale ressaltar: não se esqueça de colocar o incremento na variável da repetição, senão você já sabe: vai ocorrer um looping infinito!
Executou rapidinho, né?
O computador que executou o programa possui um bom processador, com bastante memória RAM. Em um computador com uma configuração um pouco mais modesta, não vai haver tanta diferença de tempo assim. Você viu que o resultado ficou com poucas casas decimais, e é o valor que costumamos usar. Na maioria das aplicações, esta aproximação está ótima. A não ser que você seja um astrofísico; neste caso, você precisará de um programa que exiba mais casas decimais, aliás, para cálculos astrofísicos normalmente são só 39 casas decimais! Vamos agora estudar mais uma variação de repetição.
Repetição Controlada pela Resposta do Usuário
Há muito tempo, em uma galáxia distante, os programas de computador não eram gráficos, cheio de cores, com mouse e sons bacanas, como hoje. Na atividade da aula passada, já vimos que as telas eram em modo texto e tinham que ser desenhadas usando caracteres disponíveis no sistema operacional. Olhe a tela a seguir. Esta é uma tela que usa um ambiente “gráfico”, mas que não impede o desenho pelo programador. Esse ambiente é chamado de Turbo Vision. Mas não se anime achando que nunca vai trabalhar com telas em modo texto. Muitos sistemas legados ainda usam este tipo de ambiente e, por incrível que pareça, é uma área na qual ainda existe demanda.
Veja que existe um menu na parte superior e inferior da tela. Perceba que, enquanto o usuário não usar as teclas ALT-X, o sistema continuará em execução. Ou seja, preste atenção na frase: “Até que as teclas ALT e X sejam pressionadas, continue a executar o programa”; quer dizer, temos aí uma nova estrutura de repetição. A estrutura em que vamos trabalhar agora é útil para construir menus deste tipo.
Exemplo
É claro que não vamos