Your SlideShare is downloading. ×
Algoritmo material apoio
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Algoritmo material apoio

175
views

Published on

Published in: Education

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
175
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
10
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Disciplina: Algoritmo e Programação Professor: Esp. Fábio Marques Breves - PA Fevereiro/2012
  • 2. 1 Conteúdo Plano de Ensino .............................................................................................................................. 1 Apresentação .................................................................................................................................. 2 Unidade 1: Introdução a algoritmos e programas............................................................................. 3 1.1 Introdução............................................................................................................................. 3 1.2 Formas de representação........................................................................................................ 3 1.2.1 Fluxograma .................................................................................................................... 3 1.2.2 Diagrama de bloco (ou diagrama de fluxo): .................................................................... 4 1.2.3 Algoritmo ....................................................................................................................... 4 1.2.4 UML: Unified Model Language (Linguagem de modelagem unificada).......................... 5 1.2.5 Português estruturado ..................................................................................................... 6 Unidade 2: Elementos básicos variáveis e constantes. ..................................................................... 7 2.1 Tipos de dados....................................................................................................................... 7 2.1.1 Dados numéricos ............................................................................................................ 7 2.1.2 Tipo caractere................................................................................................................. 8 2.1.2 Tipo lógico ..................................................................................................................... 8 2.2 Variáveis................................................................................................................................ 8 2.3 Constantes............................................................................................................................. 9 Unidade 3: Operadores e Expressões............................................................................................. 10 3.1 Operação de atribuição ........................................................................................................ 10 3.2 Operadores aritméticos........................................................................................................ 10 3.3 Expressões aritméticas......................................................................................................... 10 Unidade 4: Entrada e Saída de Dados............................................................................................ 12 Unidade 5: Comandos de Controle................................................................................................ 15 5.1 Desvio condicional simples ................................................................................................. 15 5.2 Operadores relacionais ........................................................................................................ 15 5.3 Desvio condicional composto.............................................................................................. 15 5.4 Desvios condicionais encadeados ........................................................................................ 16 5.5 Operadores lógicos.............................................................................................................. 18 Unidade 6: Estruturas de repetição ................................................................................................ 19 6.1 Repetição do tipo: Teste lógico no inicio do looping............................................................ 20 6.2 Repetição do tipo: Teste lógico no fim do looping ............................................................... 20 6.3 Repetição do tipo: variável de controle................................................................................ 21 6.4 Estruturas de controle encadeadas........................................................................................ 22 6.4.1 Encadeamento de estruturas de repetição enquanto com enquanto................................. 22 6.4.2 Encadeamento de estruturas de repetição enquanto com repita...................................... 23 6.4.3 Encadeamento de estruturas de repetição enquanto com para........................................ 23 6.4.4 Encadeamento de estruturas de repetição repita com repita ........................................... 23 6.4.5 Encadeamento de estruturas de repetição repita com enquanto...................................... 23 6.4.6 Encadeamento de estruturas de repetição repita com para ............................................. 23 6.4.7 Encadeamento de estruturas de repetição para com para................................................ 24 6.4.8 Encadeamento de estruturas de repetição para com enquanto........................................ 24 6.4.9 Encadeamento de estruturas de repetição para com repita ............................................. 24 Unidade 7: Tipos Estruturados de Dados....................................................................................... 25 7.1 Vetores unidimensionais ...................................................................................................... 25 7.2 Vetores bidimensionais........................................................................................................ 26 7.3 Vetores multidimensionais................................................................................................... 27 Unidade 8: Apresentação da linguagem de programação C............................................................ 28 8.2 Nosso primeiro programa .................................................................................................... 28 8.2 Entrada e Saída de Dados .................................................................................................... 30
  • 3. 8.3: Comandos de Controle ....................................................................................................... 31 8.3.1 Desvio condicional simples........................................................................................... 32 8.3.2 Desvio condicional composto ....................................................................................... 32 8.3.4 Desvios condicionais encadeados.................................................................................. 33 8.4 Estruturas de repetição......................................................................................................... 34 8.4.1 Repetição do tipo: Teste lógico no inicio do looping ..................................................... 34 8.4.2 Repetição do tipo: Teste lógico no fim do looping......................................................... 34 8.4.3 Repetição do tipo: variável de controle ......................................................................... 34 8.5 Tipos Estruturados de Dados ............................................................................................... 35 Referência Bibliográficas.............................................................................................................. 36
  • 4. 1 Plano de Ensino Identificação Geral Instituição: IFPa – Instituto Federal de Educação, Ciência e Tecnologia do Pará Curso: Licenciatura em Computação Disciplina: Algoritmos e Programação Professor: Esp. Fábio Marques Hora Aula Presencial: 64h Hora Aula Auto-estudo: 16h Total de Hora Aula: 80h Ementa Introdução a algoritmos e programas: Conceitualização das formas de representação; Elementos básicos variáveis e constantes. Operadores e Expressões: Operação de atribuição; Operadores e expressões relacionais e lógicas. Entrada e saída de dados por teclado e vídeo. Comandos de Controle: Uso de estruturas de decisão em algoritmos; Uso de estruturas de repetição em algoritmos. tipos Estruturados de Dados: Vetores unidimensionais e multidimensionais; Desenvolvimento de algoritmos. Apresentação de uma Linguagem de Programação (linguagem C). Componentes Básicos de um Programa na Linguagem C. Desenvolvimento e Programação na linguagem C. Modularização. Depuração de programas. Objetivo Apresentar ao aluno a estrutura e a funcionalidade de uma linguagem de programação utilizando formas de representações de problemas com construções de algoritmos e programas. Introduzir componentes básicos de um programa utilizando uma linguagem imperativa (linguagem C) e desenvolver a habilidade de programação utilizando de forma básica, elementos, variáveis, operadores, laços de repetição, expressões e tipos estruturados de dados. Bibliografia básica MANZANO J. A. N. G.; OLIVEIRA J. F. O. Algoritmos: lógica para desenvolvimento de programação de computadores. 14.ed. São Paulo: Érica, 2002. KERNINGHAN, B. W.; RITCHIE, D. C A Linguagem de Programação. Rio de Janeiro: Campus, 2003. ZIVIANI, Nívio. Projeto de Algoritmos: com implementações em Pascal e C. 4.ed. São Paulo: Pioneira. 1999. Bibliografia complementar: SEBESTA, ROBERT W. Conceitos de Linguagem de Programação. Porto Alegre: Bookman. 2003.
  • 5. 2 Apresentação Os algoritmos estão presentes no nosso dia a dia, em todas as nossas mais simples rotinas, as instruções para o uso de medicamentos e uma receita de culinária são alguns exemplos de algoritmos. E é claro, que formam uma importante etapa do desenvolvimento de sistemas, em toda linguagem de programação, independente de paradigma ou classificação da linguagem de programação adotada. O presente curso mostra os principais recursos disponíveis na grande maioria das linguagens de programação existentes, tais como variáveis, constantes, operadores, laços e estrutura de decisão. São utilizados pseudocódigos para facilitar o entendimento dos conceitos e elaboração de exemplos, alguns exemplos ora apresentados em pseudocódigos serão recodificados utilizando a linguagem C.
  • 6. 3 Unidade 1: Introdução a algoritmose programas 1.1 Introdução Os algoritmos estão presentes no nosso dia a dia, e pode ser visto como uma sequencia bem definida de ações a serem seguidas para se alcançar um determinado objetivo, ou para se alcançar a resolução de um conjunto de problemas de um determinado tipo. Segundo Dijkstra (1971) um algoritmo corresponde a uma descrição de um padrão de comportamento, expresso em termos de um conjunto finito de ações. Desenvolver um programa é basicamente estruturar dados e construir algoritmos. Os algoritmos construídos pelos programadores precisam possuir uma característica vital: serem seguidos por computadores. No entanto, computadores só são capazes de seguir programas (ou algoritmos) escritos em linguagem de máquina, que são sequencias binárias (zeros e uns) de difícil compreensão. Para facilitar o desenvolvimento de programas, utilizamos linguagens de programação construídas para este fim, normalmente utilizando-se de códigos próximos a linguagem falada. Para alguns programadores mais experientes, criar algoritmos intermediários, antes da codificação em uma linguagem de programação propriamente dita pode parecer perda de tempo, no entanto, a eliminação desta etapa de planejamento pode causar erros e atraso na entrega do produto final, pois a solução do problema não foi pensada de forma detalhada e com maior profundidade. Com a evolução do oficio de desenvolver sistemas, e das técnicas de programação, as formas de representação dos algoritmos e do raciocínio lógico também foram evoluindo e se modificando, conforme será apresentado no próximo item. 1.2 Formasde representação Muitas formas de representação dos algoritmos e do raciocínio lógico foram utilizadas no decorrer da evolução do oficio de se desenvolver sistemas. Independente da técnica ou da forma adotada, o objetivo era sempre obter um produto que estabelecia a sequencia de ações a serem executadas em um programa, sem o detalhamento de instruções ou comandos específicos, permitindo assim, uma posterior codificação em qualquer linguagem de programação. Veremos, a seguir, algumas das formas de representação já utilizadas. 1.2.1 Fluxograma Ferramenta gráfica desenvolvida pelos profissionais da área de análise de sistemas, que utiliza símbolos convencionais (ISO 5807:1985) tais como desenhos geométricos básicos, com a finalidade de descrever o fluxo de ação de um determinado trabalho lógico, manual ou mecânico. A Figura 1 mostra um exemplo de um fluxograma.
  • 7. 4 1.2.2 Diagrama de bloco (ou diagrama de fluxo): Ferramenta gráfica desenvolvida pelos profissionais envolvidos diretamente com a programação, utiliza-se de diversos símbolos geométricos (ISO 5807:1985), podendo ser elaborado em diversos níveis de detalhamento. Tem por objetivo a descrição do método e sequencia de processo num computador, podendo, logo após a elaboração deste diagrama, ser realizada a codificação do programa. Na Figura 2 podemos ver um diagrama de bloco, perceba que para utilização destes diagramas, faz-se necessário o conhecimento prévio de cada um dos símbolos utilizados. 1.2.3 Algoritmo São um conjunto de regras formais para a obtenção de um resultado ou para a solução de um conjunto de problemas, que se utiliza de fórmulas e expressões aritméticas para alcançar seu objetivo e é utilizado sempre que é exigido um resultado final “correto” e/ou “coerente”. Na área de desenvolvimento de sistemas, o termo algoritmo foi, muitas vezes, relacionado a diagrama de blocos, neste caso, um algoritmo gráfico. Podemos visualizar na Figura 3 um algoritmo para cálculo da situação de um estudante, mediante análise das notas obtidas pelo mesmo. Figura 1: Exemplo de fluxograma Figura 2: Exemplo de diagrama de bloco
  • 8. 5 1.2.4 UML:Unified Model Language (Linguagem de modelagem unificada). A UML é uma linguagem de modelagem não proprietária que está se tornando um padrão da indústria, sendo criada como uma forma de padronização para as diversas técnicas de representação de algoritmos e outros artefatos do desenvolvimento de sistemas. É composta por 16 diagramas, formados por um conjunto de regras e símbolos, cada um com a finalidade de documentar uma faze específica do desenvolvimento de sistemas. Na figura X, temos o diagrama de sequencia, responsável pela representação das trocas de mensagens e fluxo de dados entre as entidades do sistema. Neste caso, as trocas de mensagens necessárias entre o cliente e o servidor de e-mails. Figura 3: Algoritmo representado em diagrama de blocos
  • 9. 6 1.2.5 Portuguêsestruturado É uma técnica de algoritmização que se utiliza de narrativa em idioma corrente, denominada pseudocódigo, também conhecida por portugol. A forma original faz uso do idioma inglês, conhecido como inglês estruturado, muito próximo da notação utilizada na linguagem de programação PASCAL. Tem por vantagem ser genérica, e independente da linguagem de implementação do algoritmo. Algoritmos escritos em português estruturado podem ser facilmente utilizados para a elaboração de código em linguagem computacional (C, PASCAL, Delphi ou Java). A seguir, vemos um algoritmo escrito em português estruturado que calcula a área de um triângulo. algoritmo “AreaTriangulo” var b, h, a: REAL inicio Escreva(“Entre com o valor da base: ”) Leia (b) Escreva(“Entre com o valor da altura: ”) Leia (h) a  (b * h) / 2 Escreva(“A área desse triângulo é: ”, a) fimalgoritmo Figura 4: Exemplo de diagrama de sequencia
  • 10. 7 Unidade 2: Elementosbásicosvariáveise constantes. Para se construir algoritmos usando pseudocódigo é necessário se conheça conceitos básicos sobre dados e tipos de dados, independente da linguagem de programação. A partir desta unidade veremos a parte mais prática do desenvolvimento de algoritmos, culminando com a codificação de alguns códigos em C. Como vimos anteriormente, um algoritmo é uma sequencia bem definida de ações a serem seguidas para se alcançar um determinado objetivo, utilizaremos computadores como a ferramenta para executar esses algoritmos. Podemos dizer, a grosso modo, que a solução de problemas envolvem a manipulação de dados e instruções para a manipulação. 2.1 Tiposde dados Os dados representam as informações que serão manipuladas nos algoritmos elaborados e submetidos a um computador. Podemos dividir os dados em três tipos básicos, de acordo com a essência dos mesmos. São exemplo de dados manipuladas por algoritmos computacionais: As vendas de uma loja de departamentos; Nomes e endereços de um cadastro de clientes; Notas dos alunos de um curso; Medidas de uma experiência; Como podemos observar nos exemplos acima, os dados podem ter várias representações e são manuseados de formas diferentes no computador. Para trabalhar com esta variedade de tipos de dados é necessário conhecer bem o problema a ser resolvido, para que seja escolhido o tipo de dado certo. 2.1.1 Dadosnuméricos Os dados numéricos podem ser representados de duas maneiras distintas: inteiros ou reais, e são aqueles passíveis das operações aritméticas. 2.1.1.1 Tiponuméricointeiro São dados do tipo numérico, quer sejam negativos, positivos ou nulo, correspondendo aos números inteiros da aritmética. Também são conhecidos como números de ponto fixo, embora não apresentem pontos (ou vírgulas) em sua representação. São exemplos de números inteiros: 1508 602 0 -10 -56
  • 11. 8 2.1.1.2 Tiponuméricoreal São dados do tipo numérico, quer sejam negativos, positivos ou nulo, inclusos os números fracionários, e são utilizados por algoritmos que necessitam de um maior domínio (valor) que o oferecido pelos números inteiros. Os números reais sempre apresentam o ponto (vírgula) decimal, sendo também utilizados para representar as frações. Por limitações técnicas, a representação gráfica de frações é diferente da representação matemática, assim a representação gráfica da fração é representada da seguinte forma: 1/2. Numericamente, a fração equivale a 0.5, pois não há mecanismos para guardar numeradores e numeradores, logo, apenas o valor numérico equivalente será guardado. São exemplos de números reais: -21.04 1.44 100.8 0.0 0.5 2.1.2 Tipo caractere São dados não numéricos (aqueles não passíveis das operações aritméticas), tais como os caracteres alfabéticos, dígitos numéricos e caracteres especiais. Este tipo também é conhecido como alfanumérico, string, literal ou cadeia. Uma sequencia de caracteres deve sempre ser delimitada por um apóstrofo ( ‘’ ). Para efeito de programação deve-se notar a sintaxe da linguagem a ser utilizada, pois esses delimitadores variam de linguagem para linguagem de programação. São exemplos de cadeias de caracteres: ‘Pará’ ‘3233-3331’ ‘ ’ ‘7’ ‘BELÉM’ 2.1.2 Tipo lógico Caracterizam-se como tipo lógico os dados com valor VERDADEIRO ou FALSO, este tipo de dado pode assumir apenas um valor a cada momento. É também conhecido como tipo boleano, devido aos estudos sobre lógica matemática do filósofo inglês George Boole. A representação deste tipo de dado, quando estamos usando uma linguagem de programação, varia de linguagem para linguagem. 2.2 Variáveis O termo variável dá-se ao fato de que, em problemas computacionalmente trabalhados, o volume de informações serem extremamente grande e diversificado, ou seja, variáveis. Para que possamos armazenar algum dado na memória do computador, possibilitando assim que o mesmo seja utilizado e manipulado posteriormente, faz-se necessária a identificação do tipo do dado, ou seja, o dado precisa ser classificado segundo sua essência. O conceito de variáveis é muito familiar na matemática, e em um programa de computador ela é conhecida como uma entidade que possui um valor. Como na matemática, em informática, as variáveis têm nome e recebem valores e para identificarmos identificá-la melhor. Imagine a memória de um computador como um grande arquivo com várias gavetas,
  • 12. 9 conforme é visualizado na Figura 5, sendo que em cada gaveta é possível guardar apenas um único valor por vez, e essas gavetas, como em um arquivo, deverão estar identificadas com uma “etiqueta” contendo um nome. Este nome, será utilizado posteriormente para utilização da variável, sendo assim, deve ser único e seguir as seguintes regras:  Nomes de variáveis podem possuir um ou mais caracteres, sendo que o primeiro caractere deve ser sempre uma letra;  O nome de uma variável não poderá possuir espaços em branco, caso seja necessário deve- se usar um caractere de ligação ( _ ) para representar um espaço;  Não poderá ser usado como nome de variável uma palavra reservada para uso do compilador;  Alguns caracteres especiais não poderão ser utilizados. São exemplos de nomes válidos de variáveis: Totalizacao, LaTA, lado3, B52, Rua_das_Flores, CodProd, CPF São contra exemplos de nomes válidos de variáveis: Totalização, 3Quarteiroes, Rua das Flores, X+Y Além de seguirmos estas regras devemos prestar atenção, ainda, para o tipo de dado que uma variável deve receber. Este tipo dever ser previamente identificado para podermos armazenar o valor correto. 2.3 Constantes Por definição, constante é tudo aquilo que não se altera, que é fixo, que é estável, em programação existem diversos momentos onde este conceito pode ser aplicado, como por exemplo: no cálculo da área de uma circunferência. 2 rA   . Onde A é a variável responsável por armazenar a área, r é a variável que guardará o comprimento do raio da circunferência, que deve ser fornecido pelo usuário, e π é a constante matemática (aproximadamente 3.1415). A definição do nome da constante segue exatamente as mesmas regras que apresentamos para definição do nome de uma variável. Figura 5: Abstração gráfica da memória de um computador em nível de variável de programação.
  • 13. 10 Unidade 3: Operadorese Expressões Variáveis e constantes, desde que definidas como tipos numéricos, poderão ser utilizadas para a elaboração de cálculos matemáticos, através da elaboração de expressões aritméticas, fazendo uso dos operadores aritméticos. O resultado da avaliação de uma expressão é o valor que será atribuído à variável indicada. Vale lembrarmos que o tipo da variável indicada também deve ser cuidadosamente analisado. 3.1 Operação de atribuição Esta operação especifica que um determinado valor está sendo atribuído (guardado) em uma determinada variável, e é representada pelo símbolo de seta (  ). Logo A  3 (leia-se: variável “A” recebe três), indica que a variável A está recebendo para armazenamento o valor numérico inteiro três. A operação de atribuição de valores é destrutiva, isto é, ao atribuir-se um novo valor a variável, o valor anterior é perdido. 3.2 Operadoresaritméticos Os operadores aritméticos são classificados como binários ou unários. São classificados como binários quando envolvem dois operandos, como é o caso da multiplicação, exponenciação, divisão, adição e subtração, e são classificados como unários quando envolvem apenas um operando, como é o caso da inversão de sinais (positivo e negativo). A seguir, veremos a tabela de operadores aritméticos, bem como a ordem de prioridade dos mesmos, além do tipo e retorno de cada um deles: OPERADOR OPERAÇÃO TIPO PRIORIDADE RESULTADO + Manutenção de sinal Unário 1 Positivo - Inversão de sinal Unário 1 Negativo  Exponenciação Binário 2 Inteiro ou real * Multiplicação Binário 3 Inteiro ou real / Divisão Binário 3 Real div Resto da divisão Binário 4 Inteiro + Adição Binário 4 Inteiro ou real - Subtração Binário 4 Inteiro ou real 3.3 Expressõesaritméticas Dado ao fato que grande parte do trabalho computacional utilizar-se de cálculos matemáticos, o estudo e a utilização de expressões aritméticas (e fórmulas matemáticas) serão bastante comuns no desenvolvimento de programas. As expressões são basicamente o relacionamento entre variáveis e constantes através da utilização dos operadores aritméticos. Iremos considerar novamente, a fórmula para o cálculo da área de uma circunferência. 2 rA   , onde A representa a área da circunferência, r representa o comprimento do raio da
  • 14. 11 circunferência e onde π representa a constante matemática (aproximadamente 3.1415). A equação matemática representada na forma computacional ficaria da seguinte forma: A 3.1415 * r  2 Para a representação de expressões aritméticas em programas precisaremos nos ater a algumas diferenças existentes entre as formas matemática e computacional. A primeira característica é a inexistência de colchetes ou chaves na forma computacional, devendo ser substituídos por parênteses, que serão resolvidos dos mais internos para os mais externos da expressão. A expressão matemática )]}230(:55[43{ x será representada computacionalmente como x  (43 * (55 / (30 + 2))). Outra mudança percebida é a substituição do sinal de igualdade (=) pelo sinal de atribuição (), que indica que o valor resultante da expressão aritmética será atribuído a variável em questão (x).
  • 15. 12 Unidade 4: Entrada e Saída de Dados Um programa executável em um computador usualmente possui três itens básicos de trabalho: a entrada de dados, o seu processamento e a saída do resultado, logo, trabalharemos todas as soluções computacionais através da elaboração de programas com estes três itens. Uma consequencia disto é que se os dados forem entrados de forma errada, ou se estiverem sendo processados de forma equivocada, a resposta será um resultado errado. Agora já sabemos que qualquer erro antes atribuído a um computador, na realidade fora causado por um erro humano, quer seja voluntario ou involuntário. Quando recebemos uma cobrança indevida, ou detectamos um erro no nosso saldo bancário, podemos afirmar que se trata de um erro humano. A Figura 6 ilustra os três pontos básicos do trabalho de resolver problemas de forma computacional e suas relações. Em um programa real, a entrada e saída de dados poderão ocorrer de diferentes formas. Uma entrada de dados pode ser realizada, por exemplo, de tais formas: via teclado, via modem, através de um leitor ótico, dentre outras. Enquanto as saídas de dados podem ser realizadas, por exemplo, das seguintes formas: em vídeo, em impressora, em um arquivo em disco e etc. Devido à grande variedade de dispositivos de entrada e saída existentes, e devido à complexidade de manipulação destes nas diversas linguagens de programação, iremos nos ater em utilizar os comandos Leia, Escreva e Escreval, para representar a entrada e a saída de dados respectivamente, abstraindo a interface dos dispositivos existentes. Por motivos didáticos, adotaremos que toda entrada será realizada através do teclado, e toda saída realizada através do monitor. A diferença entre os comandos Escreva e Escreval está apenas no fato do segundo pular uma linha após escrever a lista de dados. Em Português estruturado: Leia (<lista de dados>) Escreva (<lista de dados>) Escreval (<lista de dados>) Como exemplo de um problema resolvível computacionalmente por um programa, podemos ter: “Deverá ser criado um programa que efetue a leitura de dois valores numéricos. Calcule a média aritmética dos dois valores e apresente o resultado obtido.” Figura 6: Três pontos básicos de um programa
  • 16. 13 Para a resolução de problemas como estes, precisaremos compreender bem o mesmo, e buscarmos uma solução computacional para o mesmo, delimitando os passos a serem seguidos pelo computador para resolução de tal problema de forma genérica. Para tanto, deveremos observar que será realizada a leitura de dois valores que não conhecemos (e que realmente não precisamos conhecer), e para isto, utilizaremos duas variáveis para trabalhar com as incógnitas do problema, v1 e v2. E, para trabalhar com o resultado da média, utilizaremos uma terceira variável, chamada de M. O algoritmo para resolução de tal problema seria muito parecido com o seguinte: 1. Ler dois valores numéricos (variáveis v1 e v2); 2. Efetuar o cálculo da média aritmética dos valores obtidos e guardar o resultado em M. 2 21 vv M   3. Apresentar o valor da variável M após a realização do cálculo. O algoritmo acima representa apenas uma das soluções corretas para o problema acima, podendo ser feito de diversas formas, haja vista que se trata da interpretação do referido problema. Tendo estabelecido os passos para resolução do problema de forma genérica, podemos iniciar a resolução do mesmo através da codificação, para tanto, utilizaremos a técnica da utilização do português estruturado. Todo algoritmo escrito em português estruturado deverá seguir uma estrutura rígida, conforme apresentada a seguir: Primeiro devemos definir o nome do algoritmo, que deve ser algo sugestivo, para que possamos nos lembrar do se trata o algoritmo apenas pela análise do nome, sem ter que analisar o algoritmo na integra. algoritmo “MediaAritmetica” Após a definição do nome do algoritmo, temos uma área destinada à declaração (identificação) de todas as variáveis que serão necessárias para a execução do algoritmo e obtenção do respectivo resultado. Esta área inicia-se com a palavra var, conforme abaixo: var v1, v2, M: REAL Percebe-se que as variáveis foram agrupadas, pois todas pertencem ao mesmo tipo de dado, o tipo Real. A sintaxe para declaração de variáveis é a seguinte: <lista de variáveis>: <tipo de dado> A partir de agora, podemos utilizar as variáveis, dando prosseguimento à resolução do problema. Para delimitar a área de execução das instruções que irão realizar o passo a passo utilizaremos o par inicio/fim. Note que o bloco de instruções de programa (bloco compreendido pelo par inicio/fim) é apresentado um pouco deslocado para a direita, isto se chama endentação, e facilita a leitura de um bloco do programa, por tanto, trata-se de uma boa prática endentar seus códigos de blocos. No entanto, a endentação não influencia na execução das instruções.
  • 17. 14 Para a realização da leitura do valor de uma variável utilizaremos o comando Leia indicando como argumento para o mesmo a variável desejada. Para fins informativos, e para instrução do operador do sistema, serão exibidas mensagens indicando o que o operador deve fazer, a exibição de mensagens será realizada pelo comando Escreva recebendo como argumento a mensagem a ser exibida, conforme a seguir: Escreva(“Entre com o primeiro valor: ”) Leia(v1) A seguir, realizaremos a conversão da equação 2 21 vv M   do modelo matemático para o computacional, e a atribuição do resultado a variável M: M  (v1 + v2) / 2 Só nos resta agora, exibir o resultado da expressão aritmética atribuído a variável M conforme a seguir: Escreva(“A média dos valores é: ”, M) Perceba que utilizamos o comando Escreva com dois argumentos, uma mensagem e a variável M, desta forma serão exibidos a mensagem e o valor de M respectivamente. O algoritmo completo pode ser visualizado a seguir: algoritmo “MediaAritmetica” var v1, v2, M: REAL inicio Escreva(“Entre com o primeiro valor: ”) Leia(v1) Escreva(“Entre com o segundo valor: ”) Leia(v2) M  (v1 + v2) / 2 Escreva(“A média aritmética dos valores é: ”, M) fimalgoritmo Em linhas gerais, basta que a estratégia acima adotada seja seguida sempre que se necessita escrever um algoritmo para a resolução de um problema genérico, por tanto, vamos rever a estratégia para uma melhor fixação: 1. Compreender bem o problema; 2. Buscarmos uma solução computacional para o mesmo, delimitando os passos a serem seguidos. 3. Elaborar a resolução do mesmo através da codificação em português estruturado Adicionalmente, poderíamos realizar testes sobre o nosso algoritmo: uma forma seria a reescrita do mesmo uma linguagem de programação, para que o compilador possa convertê-lo em linguagem de máquina, ou ainda a utilização de uma ferramenta que interprete o nosso português estruturado (pseudocódigo) e o execute. Uma ferramenta que realiza a interpretação de nossos pseudocódigos escritos em português estruturado é o Visualg (Visualizador de Algoritmos) como se nossos algoritmos fossem programas de computador (APOIO INFORMÁTICA, 2012).
  • 18. 15 Unidade 5: Comandosde Controle Com as informações apresentadas até agora, já conseguimos solucionar alguns problemas, como por exemplo: calcula a média das notas de um aluno. No entanto, ainda temos algumas limitações, como por exemplo, tratar a média deste aluno para realizarmos um processamento mais adequado, como a exibição de uma mensagem informando se o aluno foi ou não aprovado. Observe que a média do aluno terá de ser verificada de acordo com um parâmetro e então terá de ser tomada uma decisão: qual mensagem imprimir. 5.1 Desvio condicional simples Para a resolução do problema da mensagem de aprovação do aluno, será necessário conhecermos uma nova instrução: se...então...fimse. Esta instrução desvia a execução do algoritmo para uma determinada área de acordo com a condição, caso a condição seja VERDADEIRA, serão executados todos os comandos entre o se...então, e caso a condição seja FALSA serão executados todos os comandos após o fimse. se <condição> entao <sequencia de comandos> fimse 5.2 Operadoresrelacionais Para a utilização da instrução se...entao...fimse precisaremos conhecer os operadores relacionais para que possamos verificar o estado de uma variável enquanto VERDADEIRO ou FALSO. Esta verificação é efetuada com a utilização dos operadores relacionais, conforme tabela a seguir: SÍMBOLO SIGNIFICADO = Igual a <> Diferente de > Maior que < Menor que >= Maior ou igual que <= Menor ou igual que 5.3 Desvio condicional composto Para a realização de desvios condicionais compostos, faremos uso da instrução se...então...senao...fimse, onde sendo a condição VERDADEIRA, serão executadas todas as instruções que estiverem localizadas entre o se...entao e a instrução senao, enquanto que se a condição for FALSA, serão executadas todas as instruções que estiverem localizadas entre o senao e a instrução fimse. se <condição> entao <sequencia de comandos para condição VERDADEIRA> senao <sequencia de comandos para condição FALSA> fimse
  • 19. 16 Com o conhecimento prévio das estruturas de decisão simples e composta, podemos retomar a solução do problema da média: “Deverá ser criado um programa que efetue a leitura das duas notas obtidas por um aluno. Calcule a média aritmética dos dois valores e apresente a mensagem APROVADO caso a média seja maior ou igual a 7 ou REPROVADO, caso contrário.” 1. Ler dois valores numéricos (variáveis n1 e n2); 2. Efetuar o cálculo da média aritmética dos valores obtidos e guardar o resultado em M. 2 21 nn M   3. Se o valor da variável M for maior que 7 apresentar a mensagem APROVADO ou REPROVADO caso contrário. Algoritmo em português estruturado: algoritmo “SituacaoAluno” var n1, n2, M: REAL inicio Escreva(“Entre com a primeira nota: ”) Leia(n1) Escreva(“Entre com a segunda nota: ”) Leia(n2) M  (n1 + n2) / 2 Se (M >= 7) entao Escreva(“APROVADO”) Senao Escreva(“REPROVADO”) Fimse fimalgoritmo 5.4 Desvioscondicionaisencadeados Em alguns problemas, será necessário combinar condições sucessivas para garantir que uma ação somente seja executada se o conjunto de condições seja satisfeito. Para o conjunto de instruções, ainda pode ser definido um novo conjunto de condições para serem testadas. Para este tipo de estrutura de desvios condicionais, com diversos níveis de condição chamamos de aninhamento ou encadeamento. se <condição> entao < comandos para condição1 VERDADEIRA> senao se <condição2> entao <comandos para condição1 e condição2 VERDADEIRAS> senao <comandos para condição1 VERDADEIRA e condição2 FALSA> fimse fimse O encadeamento foi realizado apenas na condição1 sendo FALSA, no entanto, o mesmo poderá ser aplicado caso a condição1 fosse VERDADEIRA, ou até mesmo nos dois casos.
  • 20. 17 Com o conhecimento de desvios condicionais encadeados, podemos resolver o seguinte problema: “Deverá ser criado um programa que efetue a leitura das duas notas obtidas por um aluno. Calcule a média aritmética dos dois valores e apresente a mensagem APROVADO caso a média seja maior ou igual a 7 ou RECUPERACAO caso a média seja maior que 5 ou ainda REPROVADO, caso contrário.” 1. Ler dois valores numéricos (variáveis n1 e n2); 2. Efetuar o cálculo da média aritmética dos valores obtidos e guardar o resultado em M. 2 21 nn M   3. Se o valor da variável M for maior que 7 apresentar a mensagem APROVADO ou RECUPERACAO caso a média seja maior que 5 ou REPROVADO caso contrário. Algoritmo em português estruturado: algoritmo “SituacaoAluno2” var n1, n2, M: REAL inicio Escreva(“Entre com a primeira nota: ”) Leia(n1) Escreva(“Entre com a segunda nota: ”) Leia(n2) M  (n1 + n2) / 2 Se (M >= 7) entao Escreva(“APROVADO”) Senao Se (M >= 5) entao Escreva(“RECUPERAÇÃO”) Senao Escreva(“REPROVADO”) Fimse Fimse fimalgoritmo
  • 21. 18 5.5 Operadoreslógicos Os operadores lógicos, assim como os operadores aritméticos, realizam a operação entre operandos, neste caso, operandos lógicos. Também se classificam em unários e binários, de forma análoga aos operadores aritméticos. A seguir, veremos a tabela de operadores lógicos, bastante reduzida, se compararmos a tabela de operadores aritméticos. OPERADOR OPERAÇÃO TIPO RESULTADO AND E Binário VERDADE se ambas as variáveis de entrada forem VERDADE. OR OU Binário VERDADE se pelo menos uma das variáveis de entrada forem VERDADE. XOR OU EXCLUSIVO Binário VERDADE se e somente se exatamente uma das variáveis de entrada for VERDADE. NOT NÃO Unário Negação da variável atual. A seguir, veremos as tabelas-verdade (resultados) dos operadores acima relacionados. Tabela verdade para o operador lógico AND. OPERANDO 1 OPERANDO 2 OP1 AND OP2 VERDADEIRO VERDADEIRO VERDADEIRO VERDADEIRO FALSO FALSO FALSO VERDADEIRO FALSO FALSO FALSO FALSO Tabela verdade para o operador lógico OR. OPERANDO 1 OPERANDO 2 OP1 OR OP2 VERDADEIRO VERDADEIRO VERDADEIRO VERDADEIRO FALSO VERDADEIRO FALSO VERDADEIRO VERDADEIRO FALSO FALSO FALSO Tabela verdade para o operador lógico XOR. OPERANDO 1 OPERANDO 2 OP1 XOR OP2 VERDADEIRO VERDADEIRO FALSO VERDADEIRO FALSO VERDADEIRO FALSO VERDADEIRO VERDADEIRO FALSO FALSO FALSO Tabela verdade para o operador lógico NOT. OPERANDO NOT OP VERDADEIRO FALSO FALSO VERDADEIRO
  • 22. 19 Unidade 6: Estruturasde repetição Em alguns problemas faz-se necessária a repetição de um determinado trecho de instruções por um determinado número de vezes. Nesses casos, realiza-se um looping que efetue a repetição do determinado trecho pelo determinado número de vezes. Os loopings também são conhecidos como laços de repetição ou malhas de repetição. Com os conhecimentos adquiridos até o momento, teríamos de repetir o trecho de código quantas vezes fossem necessárias, por exemplo, no seguinte problema: “Deverá ser criado um programa que efetue a leitura de três valores numéricos. Calcule o triplo de cada um deles e apresente o valor obtido respectivamente.” 1. Ler um valor numérico (variável valor); 2. Efetuar o cálculo do triplo do valor e guardar o resultado em triplo. 3 valortriplo 3. Apresentar o valor da variável triplo. 4. Ler um valor numérico (variável valor); 5. Efetuar o cálculo do triplo do valor e guardar o resultado em triplo. 3 valortriplo 6. Apresentar o valor da variável triplo. 7. Ler um valor numérico (variável valor); 8. Efetuar o cálculo do triplo do valor e guardar o resultado em triplo. 3 valortriplo 9. Apresentar o valor da variável triplo. Algoritmo em português estruturado: algoritmo “ValorTripo1” var valor, triplo: REAL inicio // primeira vez Escreva(“Entre com o valor: ”) Leia(valor) triplo  valor * 3 Escreval(“O triplo do valor é: ”, triplo) // segunda vez Escreva(“Entre com o valor: ”) Leia(valor) triplo  valor * 3 Escreval(“O triplo do valor é: ”, triplo) // terceira vez Escreva(“Entre com o valor: ”) Leia(valor) triplo  valor * 3 Escreval(“O triplo do valor é: ”, triplo) fimalgoritmo Para a resolução deste tipo de problema, existem instruções mais apropriadas que determinam um número variado de repetições, gerando códigos mais elegantes e menores.
  • 23. 20 6.1 Repetição do tipo: Teste lógico no inicio do looping Tem como principal característica a realização de um teste lógico no início do looping, verificando se o trecho de instruções subordinadas ao looping poderá ou não ser executada. Esta estrutura de repetição é a enquanto...faça...fimenquanto. enquanto <condição> faça <sequencia de instruções> fimenquanto Reescrita do algoritmo ValorTripo em português estruturado com o uso do enquanto...faça...fimenquanto: algoritmo “ValorTripo2” var i: INTEIRO valor, triplo: REAL inicio i  1 Enquanto i <= 3 faca Escreva(“Entre com o valor: ”) Leia(valor) triplo  valor * 3 Escreval(“O triplo do valor é: ”, valor) i  i + 1 Fimenquanto fimalgoritmo Para a resolução deste problema, com o uso da estrutura de repetição enquanto...faça...fimenquanto, precisamos criar uma variável para controlar as iterações (repetições), esta variável foi chamada de i e é do tipo INTEIRO. Esta variável recebe o valor 1 antes do início do looping, e é incrementada ao final de cada looping, para que possa ser testada no início da próxima iteração. 6.2 Repetição do tipo: Teste lógico no fim do looping Esta estrutura assemelha-se a anterior, diferindo apenas no fato de que o teste será realizado apenas no final do looping, sendo assim, podemos dizer que esta estrutura de repetição tem o funcionamento no sentido contrário da anterior. Por consequencia disso, tem-se que o bloco de instruções será executado sempre, pelo menos uma vez. A estrutura de repetição é a repita...ate. repita <sequencia de instruções> ate <condição>
  • 24. 21 Reescrita do algoritmo ValorTripo em português estruturado com o uso do repita...ate: algoritmo “ValorTripo3” var i: INTEIRO valor, triplo: REAL inicio i  1 Repita Escreva(“Entre com o valor: ”) Leia(valor) triplo  valor * 3 Escreval(“O triplo do valor é: ”, triplo) i  i + 1 Ate i > 3 fimalgoritmo Para esta solução, utilizando a estrutura de repetições repita...ate também utilizamos uma variável de controle chamada i, no entanto, perceba que a condição demonstrou-se contrária a condição da estrutura enquanto...faça...fimenquanto. 6.3 Repetição do tipo: variável de controle Nas duas estruturas de repetição anteriores, fizemos o uso de uma variável para controlar o número de iterações, no entanto, existem estruturas de repetição que realizam o controle dessa variável de forma controlada pela própria estrutura de repetição. Com a estrutura para...faça poderemos executar loopings com um número finito de iterações, ou seja, nesses casos, não é obrigatório conhecer antecipadamente o número de interações que devem ser executadas. para <variável> de <inicio> ate <fim> [passo <incremento>] faca <sequencia de instruções> fimpara Reescrita do algoritmo ValorTripo em português estruturado com o uso do para...faça: algoritmo “ValorTripo3” var i: INTEIRO valor, triplo: REAL inicio Para i de 1 ate 3 faca Escreva(“Entre com o valor: ”) Leia(valor) triplo  valor * 3 Escreval(“O triplo do valor é: ”, triplo) i  i + 1 Fimpara Fimalgoritmo
  • 25. 22 6.4 Estruturasde controle encadeadas Dependendo do problema a ser resolvido, também é possível o aninhamento, ou encadeamento, de estruturas de controle, assim como nas estruturas de decisão. 6.4.1 Encadeamento de estruturasde repetição enquanto com enquanto Neste caso particular, utilizaremos duas instruções enquanto encadeadas, onde a sequencia de instruções contidas dentro do enquanto mais interno será executada enquanto a condição1 e condição2 forem verdadeiras. Perceba que o laço mais interno é executado a cada iteração do laço mais externo. enquanto <condição1> faca enquanto <condição2> faca <sequencia de instruções> fimenquanto fimenquanto Vamos analisar o algoritmo em português estruturado abaixo. algoritmo “EnquantosEncadeados” var i, j: INTEIRO inicio i  1 j  1 Enquanto i < 3 faca Enquanto j < 5 faca Escreval(“i vale ”, i, “ e j vale ”, j) j  j + 1 Fimenquanto i  i + 1 Fimenquanto Fimalgoritmo Agora, vamos analisar a saída do console: i vale 1 e j vale 1 i vale 1 e j vale 2 i vale 1 e j vale 3 i vale 1 e j vale 4 i vale 2 e j vale 1 i vale 2 e j vale 2 i vale 2 e j vale 3 i vale 2 e j vale 4 *** Fim da execução. Perceba que houve duas iterações de j (laço mais interno), uma para cada iteração de i (laço mais externo.
  • 26. 23 6.4.2 Encadeamento de estruturasde repetição enquanto com repita Neste caso particular, utilizaremos uma instrução enquanto e uma instrução repita. enquanto <condição1> faca repita <sequencia de instruções> ate <condição2> fimenquanto 6.4.3 Encadeamento de estruturasde repetição enquanto com para Neste caso particular, utilizaremos uma instrução enquanto e uma instrução para. enquanto <condição1> faca para <variável> de <inicio> ate <fim> [passo <incremento>] faca <sequencia de instruções> fimpara fimenquanto 6.4.4 Encadeamento de estruturasde repetição repita com repita Neste caso particular, utilizaremos duas instruções repita encadeadas. repita repita <sequencia de instruções> ate <condição2> ate <condição1> 6.4.5 Encadeamento de estruturasde repetição repita com enquanto Neste caso particular, utilizaremos uma instrução repita e uma instrução enquanto. repita enquanto <condição2> faca <sequencia de instruções> fimenquanto ate <condição1> 6.4.6 Encadeamento de estruturasde repetição repita com para Neste caso particular, utilizaremos uma instrução repita e uma instrução para. repita para <variável> de <inicio> ate <fim> [passo <incremento>] faca <sequencia de instruções> fimpara ate <condição1>
  • 27. 24 6.4.7 Encadeamento de estruturasde repetição para com para Neste caso particular, utilizaremos duas instruções para encadeadas. para <variável> de <inicio> ate <fim> [passo <incremento>] faca para <variável> de <inicio> ate <fim> [passo <incremento>] faca <sequencia de instruções> fimpara fimpara 6.4.8 Encadeamento de estruturasde repetição para com enquanto Neste caso particular, utilizaremos uma instrução para e uma instrução enquanto. para <variável> de <inicio> ate <fim> [passo <incremento>] faca enquanto <condição> faca <sequencia de instruções> fimenquanto fimpara 6.4.9 Encadeamento de estruturasde repetição para com repita Neste caso particular, utilizaremos uma instrução para e uma instrução repita. para <variável> de <inicio> ate <fim> [passo <incremento>] faca repita <sequencia de instruções> ate <condição> fimpara
  • 28. 25 Unidade 7: TiposEstruturadosde Dados Até o momento, realizamos o estudo apenas de variáveis do tipo simples, ou seja, aquelas que armazenam apenas um valor por vez. A partir de agora, estaremos estudando uma técnica que nos permitirá manipular um agrupamento de dados homogêneos dentro de uma única variável. Classifica-se como uma estrutura de dados homogêneos, pois os dados armazenados sempre obedecerão ao mesmo tipo de dado definido no momento da declaração da estrutura. Na literatura encontramos diversas nomenclaturas para este tipo estruturado de dados, tais como: variáveis indexadas, variáveis compostas, variáveis subscritas, arranjos, arrays (do inglês), vetores, matrizes e outros. No nosso estudo defini-las-emos como vetores. Vale lembrar que as regras para nomenclatura de tipos estruturados de dados seguem as mesmas regras das variáveis do tipo simples, vistas anteriormente. 7.1 Vetoresunidimensionais Caracteriza-se pela definição de uma única variável dimensionada por uma constante inteira positiva que define o tamanho da mesma. Para entendermos melhor o uso deste tipo de estrutura, vamos imaginar a seguinte situação: suponha que exista uma relação de alunos com o nome de cada estudante e a nota da primeira prova da disciplina Algoritmos e Programação. Deve-se imprimir o nome de cada estudante cuja nota é maior do que a nota média da classe. Utilizando variáveis simples, deveríamos criar uma variável para armazenar o nome de cada estudante (isto é: nome1, nome2, nome3, ..., nomeN: CARACTERE), e uma variável para cada nota de cada aluno (isto é: nota1, nota2, nota3, ..., notaN: REAL). Note que para a existência de um número consideravelmente grande de alunos haverá um número extraordinariamente grande de variáveis. Uma solução mais adequada seria utilizarmos um conjunto para armazenar os nomes e um conjunto para armazenar as notas dos estudantes, neste caso, tanto a variável de nomes quanto de notas, seriam vetores unidimensionais. Caso a relação possua 20 alunos, as variáveis nomes e notas seriam um conjunto com 20 elementos cada. Sendo assim, a variável nome[1] indica o nome do primeiro aluno, sendo chamada de variável indexada. O índice da variável poderá ser substituído por uma variável, sendo utilizado o valor da mesma para descobrir-se a posição no vetor. Utilizando os conhecimentos a respeito de vetores, podemos agora escrever o algoritmo para a solução do problema com cinco alunos 1. Ler o nome e a primeira nota de cada um dos alunos; 2. Efetuar o cálculo da média das notas lidas, guardando o resultado em M. 5  notas M 3. Verificar quais alunos ficaram acima da média e imprimir seus nomes.
  • 29. 26 algoritmo “VetorUnidimensional” var nomes: vetor [1..5] de caractere notas: vetor [1..5] de real i: INTEIRO media: REAL inicio media  0 // Lendo o nome e notas; somando as notas Para i de 1 ate 5 faca Escreva(“Entre com o nome do ”, i, “º aluno: ”) Leia(nomes[i]) Escreva(“Entre com a nota do ”, i, “º aluno: ”) Leia(notas[i]) media  media + notas[i] Fimpara // Calculando a média media  media / 5 // Imprimindo os nomes dos alunos acima da média Escreval (“*** Lista de alunos acima da média”) Para i de 1 ate 5 faca Se notas[i] > media entao Escreval(nomes[i]) Fimse Fimpara Fimalgoritmo 7.2 Vetoresbidimensionais Anteriormente, vimos que os vetores unidimensionais possuíam apenas uma dimensão, no entanto, a partir de agora, conheceremos uma nova opção, que será a de utilizarmos vetores bidimensionais. Devemos lembrar que trata-se de um tipo homogêneo de dados, logo, todos os elementos devem obedecer o tipo declarado. Os vetores bidimensionais são usados para a representação de tipos estruturados de dados na forma de tabelas. O vetor bidimensional também é uma variável do tipo indexada, no entanto, esta possui dois índices: um para especificar as linhas, o primeiro; outro para especificar a coluna, o segundo. A seguir, vemos a representação gráfica de uma tabela de vendas de uma loja de eletrodomésticos, tal estrutura poderá ser armazenada utilizando-se um vetor bidimensional. A célula em destaque, que representa as vendas da quarta semana do “Eletrodoméstico 2” será representada pelo índice [4, 2].
  • 30. 27 Semana Eletrodoméstico 1 Eletrodoméstico 2 Eletrodoméstico 3 Eletrodoméstico 4 1 6 3 9 5 2 5 10 3 2 3 7 8 8 5 4 8 10 12 7 5 4 7 3 3 6 7 15 5 4 7.3 Vetoresmultidimensionais Como visto, podemos ter vetores com uma única dimensão, os monodimensionais, com duas dimensões, os bidimensionais, e agora, veremos que os vetores podem apresentar mais de duas dimensões, sendo classificados como vetores multidimensionais. Suponha que o Museu de Carros Antigos está conduzindo um levantamento dos carros antigos do Estado de São Paulo. Cada carro possui um registro com as seguintes informações: fabricante (um código inteiro de zero a trinta), o ano do carro (de 1900 a 1950) e as condições do carro (1 - ruim, 2 - regular, 3 - boa, 4 - excelente). Para permitir a execução de várias análises nos dados, estes são armazenados num conjunto tridimensional, como o mostrado abaixo: Logo, para o carro em destaque seria indexado pelo código do fabricante [26], pelo ano [1904] e pelo estado de conservação [2] e teria o código 6. Logo, se o vetor chamar-se carros, teríamos um item como: carros[26, 1904, 2] = 6. Condição Fabricante Ano 1900 1950 30 0 4 2 26 1904 6
  • 31. 28 Unidade 8: Apresentação da linguagem de programação C Estaremos apresentando, neste capítulo, aspectos básicos de uma poderosa linguagem de programação, sendo bastante genérica para ser utilizada para a criação de diversos programas, tais como: processadores de texto, sistemas operacionais, programas para solução de diversos problemas da Engenharia, Física e outras ciências. Estaremos apresentando uma estrutura particular do C, padronizada pela ANSI, chamada de ANSI C. Esta unidade visa apresentar apenas os aspectos mais elementares da linguagem, que permita ao aluno desenvolver os algoritmos acima expostos, bem como os exercícios disponibilizados, um curso mais completo da linguagem C, bastante consolidado, que vêm sendo disponibilizado desde 1996, pode ser acessado gratuitamente a partir da página da UFSC (CPDEE/UFMG, 2012). A linguagem de programação C nasceu ainda na década de 70, sendo implementada por Dennis Ritchie, derivada de uma outra linguagem chamada B, criada por Ken Thompson. Originalmente, o C foi implementada em DEC PDP-11 rodando o sistema operacional UNIX. Uma das características primeiramente percebidas pelos iniciantes da programação, é que o C é case-sensitive, e isso significa dizer que as letras maiúsculas são diferentes das letras minúsculas, isso é: “Media” é diferente de “media”, que é diferente de “mEdia”, logo, o nome de variáveis e de instruções tem de ser grafados exatamente como o exposto. Por tratar-se de uma verdadeira linguagem de programação, nossos códigos escritos na linguagem C (muito próximos do inglês) têm de ser traduzidos para a linguagem compreendida pelo computador, ou seja, linguagem binária. A tradução do nosso arquivo em formato texto para um arquivo binário é realizada pelo compilador. Existem diversos compiladores C disponíveis gratuitamente na internet, aconselhamos o compilador Dev-C++ (BLOODSHED, 2012), que possui um ambiente de desenvolvimento para o ambiente Windows, além de estar com este ambiente quase todo traduzido para o Português Brasileiro. 8.2 Nosso primeiro programa Estaremos agora, elaborando o nosso primeiro programa utilizando a linguagem C, trata-se do mais famoso primeiro programa desenvolvido pelos aprendizes de uma linguagem de programação: Hello word! (Olá mundo!). Logo o problema seria descrito da seguinte forma: “Deverá ser criado um programa que apresente a mensagem: Olá Mundo !” O algoritmo para resolução de tal problema seria muito parecido com o seguinte: 1. Apresentar a mensagem “Olá mundo!”. Em português estruturado teríamos o seguinte código: algoritmo “OlaMundo” inicio Escreva(“Olá mundo!”) Fimalgoritmo
  • 32. 29 A tradução para a linguagem C é apresentada abaixo: #include <iostream> int main() { printf(“Olá mundo!n”); system(“PAUSE”); } Observando o código, percebemos o primeiro comando #include < iostream>, este comando, informa ao compilador deve incluir o arquivo-cabeçalho iostream. Este arquivo é responsável declarações de funções úteis para entrada e saída de dados, daí o seu nome: Standard Input/Output (entrada e saída padrão, do inglês). Esse comando, de inclusão do arquivo-cabeçalho stdio.h será utilizado sempre que formos utilizar algum comando de entrada ou saída (Escreva / Leia do português estruturado). Outra característica da linguagem é a obrigatoriedade da criação de uma função chamada main, pois é ela quem será chamada quando o programa for executado, e possui por padrão a seguinte assinatura. int main() { } Entre as chaves deverão ser escritos todos os códigos na linguagem C, seria o equivalente ao par início/fimalgoritimo do português estruturado. A apresentação do texto na tela deve-se a instrução printf que recebe como parâmetro o conteúdo a ser exibido, neste caso “Olá Mundo!”. Já o comando system(“PAUSE”) faz a pausa ao final da execução do programa, do contrário, a janela se fecharia tão rápido que não conseguiríamos ler a mensagem exibida. Uma curiosidade da linguagem é a existência constante de controle ou especiais, chamas constante barra ou constantes barra invertida, que podem ser adicionados as mensagens a serem exibidas para causar um determinado efeito, neste caso, utilizamos os caracteres n (new line) que gera uma quebra de linha, dando um efeito similar ao comando Escreval do português estruturado, logo, após imprimir “Ola Mundo!” o cursor passará para a próxima linha. Os caracteres barra existentes na linguagem C são os seguintes: Caractere Significado Descrição t Tabulação horizontal Move o cursor para a próxima parada de tabulação. r Carriage return Posiciona o cursor no início da linha atual. a Alerta Faz soar a campainha do sistema. 0 Null Caractere que em C termina um conjunto de caracteres. n Nova linha Posiciona o cursor no início da nova linha. Observe também que as instruções escritas em C possuem um ponto-e-vírgula (;) para identificar o término daquela instrução.
  • 33. 30 8.2 Entrada e Saída de Dados Agora que já vimos os primeiros conceitos da linguagem C, podemos nos aventurar em um programa mais completo, contendo uma entrada e saída de dados. Veja o seguinte problema: “Deverá ser criado um programa leia um valor numérico referente a uma quantidade em dias, e imprima a quantidade de anos referentes aos dias.” 1. Ler um valor numérico referente a quantidade de dias (variável dias); 2. Realizar a conversão de dias em anos e guardar na variável anos. 25.365 dias anos  . 3. Apresentar o conteúdo da variável anos após o cálculo. Em português estruturado teríamos: algoritmo “DiasAnos” var dias: INTEIRO anos: REAL inicio Escreva(“Entre com o número de dias: ”) Leia(dias) anos  dias / 365.25 Escreva(dias, “ dia(s) equivalem a ”, anos, “ ano(s).”) Fimalgoritmo Já o mesmo algoritmo escrito em C seria: #include <iostream> int main () { // declaração das variáveis int dias; float anos; // Entrada, processamento e saída de dados printf ("Entre com o número de dias: "); scanf ("%d", &dias); anos = dias / 365.25; printf ("nn%d dias equivalem a %f anos.n", dias, anos); system(“PAUSE”); } Pudemos observar algumas novidades no código acima, como por exemplo, a declaração das variáveis dias e anos, dos tipos int (inteiro) e float (real) respectivamente. Os tipos básicos suportados pelo C são os seguintes:
  • 34. 31 Tipo Significado Descrição char Caractere O valor armazenado é um caractere. Caracteres geralmente são armazenados em códigos (usualmente o código ASCII). int Inteiro Número inteiro é o tipo padrão e o tamanho do conjunto que pode ser representado normalmente depende da máquina em que o programa está rodando, normalmente de -2.147.483.648 a 2.147.483.647 float Real Número em ponto flutuante (real) de precisão simples, com seis dígitos de precisão. double Precisão dupla Número em ponto flutuante (real) de precisão dupla, com dez dígitos de precisão. void Indefinido Este tipo serve para indicar que um resultado não tem um tipo definido. Uma das aplicações deste tipo em C é criar um tipo vazio que pode posteriormente ser modificado para um dos tipos anteriores. Utilizamos também a instrução scanf (equivalente ao Leia do português estruturado), ela recebe como parâmetros, o tipo de dado a ser lido, “%d” neste caso, que representa que será lido um dado inteiro, e o endereço da variável onde será guardada a informação lida (representa-se o endereço de uma variável pelo símbolo de percentual % e o nome da variável). Há também o uso de uma expressão aritmética bem simples e similar aquelas que vínhamos utilizando em nossos pseudo-códigos em português estruturado. A instrução printf (equivalente ao Escreva do português estruturado) também está recebendo dois caracteres barra n (nova linha), e os caracteres %d e %f que exibirão um inteiro e um real respectivamente na tela, no meio do restante do texto. Segue uma lista dos códigos % disponíveis na linguagem C: Código Significado %d Inteiro %f Float %c Caractere %s String %% Coloca um % na tela 8.3: Comandosde Controle Veremos agora as equivalências entre os comandos de controle existentes no português estruturado e na linguagem C.
  • 35. 32 8.3.1 Desvio condicional simples Sintaxe em português estruturado: se <condição> entao <sequencia de comandos> fimse Sintaxe em C: if (<condição>) { <sequencia de comandos> } Código escrito em C: #include <iostream> int main () { int num; printf (“Digite um numero: ”); scanf (“%d”, &num); if (num > 10) { printf (“O número digitado é maior que 10!n”); } system(“PAUSE”); } 8.3.2 Desvio condicional composto Sintaxe em português estruturado: se <condição> entao <sequencia de comandos para condição VERDADEIRA> senao <sequencia de comandos para condição FALSA> fimse Sintaxe em C: if (<condição>) { <sequencia de comandos para condição VERDADEIRA> } else { <sequencia de comandos para condição FALSA> }
  • 36. 33 Código escrito em C: #include <iostream> int main () { int num; printf (“Digite um numero: ”); scanf (“%d”, &num); if (num >= 10) { printf (“O número digitado é maior ou igual a 10!n”); } else { printf (“O número digitado é menor que 10!n”); } system(“PAUSE”); } 8.3.4 Desvioscondicionaisencadeados Sintaxe em português estruturado se <condição1> entao < comandos para condição1 VERDADEIRA> senao se <condição2> entao <comandos para condição1 e condição2 VERDADEIRAS> senao <comandos para condição1 VERDADEIRA e condição2 FALSA> fimse fimse Sintaxe em C: if (<condição1>) { <sequencia de comandos para condição1 VERDADEIRA> } else { if (<condição2>) { <comandos para condição1 e condição2 VERDADEIRAS> } else { <sequencia comandos para condição1 VERDADEIRA e condição2 FALSA> } } Código escrito em C: #include <iostream> int main () { int num; printf (“Digite um numero: ”); scanf (“%d”, &num); if (num >= 10) { printf (“O número digitado é maior ou igual a 10!n”); } else { if (num >= 5) { printf (“O número digitado está entre 5 e 10!n”); } else { printf (“O número digitado está entre 0 e 5!n”); } } system(“PAUSE”); }
  • 37. 34 8.4 Estruturasde repetição Veremos agora as equivalências entre as estruturas de repetição existentes no português estruturado e na linguagem C. 8.4.1 Repetição do tipo: Teste lógico no inicio do looping Sintaxe em português estruturado: enquanto <condição> faça <sequencia de instruções> fimenquanto Sintaxe em C: while (<condição>) { <sequencia de instruções> } 8.4.2 Repetição do tipo: Teste lógico no fim do looping Sintaxe em português estruturado: repita <sequencia de instruções> ate <condição> Sintaxe em C: do { <sequencia de instruções> } while (<condição>); 8.4.3 Repetição do tipo: variável de controle Sintaxe em português estruturado: para <variável> de <inicio> ate <fim> [passo <incremento>] faca <sequencia de instruções> fimpara Sintaxe em C: for (<inicialização>; <condição> ; <incremento>) { <sequencia de instruções> } Código escrito em C: #include <iostream> int main () { int i; for (i = 1; i <= 100; i = i + 1) { printf ("%d n", i); } system(“PAUSE”); }
  • 38. 35 8.5 TiposEstruturadosde Dados Como vimos anteriormente, existem os tipos simples de dados e os tipos estruturados, vejamos agora como utilizar os tipos estruturados no C. A declaração de um vetor em C, é caracterizada pelo tipo de dado a ser armazenado, o nome e o tamanho do vetor. Adicionalmente o vetor poderá ser inicializado no momento de sua declaração. Sintaxe em C: tipo nome_vetor[tamanho] = {lista_de_valores}; Veja o exemplo de código C que utiliza um vetor unidimensional. #include <iostream> int main () { int i, soma, valores[10]; for (i = 1; i <= 10; i = i + 1) { printf (“Entre com o %dº valor: ”, i); scanf (“%d”, &valores[i]); } soma = 0; for (i = 1; i <= 10; i = i + 1) { soma = soma + valores[i]; } printf (“nnA soma dos valores informados foi: %dn”, soma); system(“PAUSE”); }
  • 39. 36 Referência Bibliográficas Apoio Informática. VisuAlg: Editor e Interpretador de Pseudocódigos. Disponível em: <http://www.apoioinformatica.inf.br/o-visualg>. Acesso em 30 Jan 2012. Bloodshed. Dev-C++. Disponível em: <http://www.bloodshed.net/dev/>. Acesso em 01 Fev 2012. CPDEE/UFMG. Curso de C. Disponível em: < http://www.mtm.ufsc.br/~azeredo/cursoC/>. Acesso em 01 Fev 2012. Dijkstra, E.W. (1971) A Short Introduction to the Art of Programming. Technological University Endhoven.

×