Buscar

Logica de Programação - Prof. Edgar Gurdel - Estácio

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 3, do total de 63 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 6, do total de 63 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 9, do total de 63 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Prévia do material em texto

UNIVERSIDADE ESTÁCIO DE SÁ 
 
CURSO DE ENGENHARIA 
 
 
 
 
LÓGICA DE PROGRAMAÇÃO 
 
PROF. M. Sc. EDGAR GURGEL 
 
RIO DE JANEIRO 
Lógica de Programação – Prof. Edgar Gurgel 
Página 2 de 63 
SUMÁRIO 
I - Algoritmos e Fluxogramas ........................................................................... 4	
  
1 - Introdução .................................................................................................................... 4	
  
2 - Conceito de Algoritmo ................................................................................................ 5	
  
3 - Exemplos Informais de Algoritmos ............................................................................ 6	
  
3.1 - Exemplo 1: Troca de uma lâmpada queimada ................................................. 6	
  
4 - Exemplo de um Algoritmo .......................................................................................... 7	
  
5 - Fluxogramas (Diagrama de Blocos) ............................................................................ 8	
  
Exercícios: ...................................................................................................................... 10	
  
II - Conceitos Básicos ..................................................................................... 11	
  
1 - Tipos Primitivos de Dados ........................................................................................ 11	
  
2 - Constantes ................................................................................................................. 11	
  
3 - Variáveis .................................................................................................................... 12	
  
4 - Identificadores ........................................................................................................... 12	
  
5 - Expressões Aritméticas ............................................................................................. 13	
  
6 - Expressões Lógicas ................................................................................................... 14	
  
7 - Cadeias de Caracteres ................................................. Error! Bookmark not defined.	
  
8 - Comando de Atribuição ............................................................................................ 15	
  
9 - Entrada e Saída de Dados .......................................................................................... 16	
  
10 Blocos ........................................................................................................................ 17	
  
Exercícios: ...................................................................................................................... 18	
  
III - Estrutura de Sequência ............................................................................ 19	
  
1 - Introdução .................................................................................................................. 19	
  
2 - Conceito de Sequência .............................................................................................. 19	
  
3 – Exemplos .................................................................................................................. 19	
  
Exercícios: ...................................................................................................................... 23 
IV - Estrutura de Seleção ................................................................................ 24	
  
1 - Conceito de Seleção .................................................................................................. 24	
  
2 - Seleção Simples ......................................................................................................... 24	
  
3 - Seleção Composta ..................................................................................................... 25	
  
4 - Seleção Encadeada (Se´s encaixados) ....................................................................... 27	
  
5 - Seleção de Múltipla Escolha (Estrutura Caso) .......................................................... 28 
Exercícios: ...................................................................................................................... 31 
V – Função ........................................................................................................ 32	
  
1 - Funções Numéricas .......................................................................................... 
Error! Bookmark not defined. 
Exercícios: ...................................................................................................................... 31 
VI - Estrutura de Repetição ............................................................................. 32	
  
1 - Conceito de Repetição ............................................................................................... 38	
  
2 - Enquanto (Repetição com Teste no Início) ............................................................... 38	
  
3 - Repita (Repetição com Teste no Final) ..................................................................... 40	
  
4 - Para (Repetição com Variável de Controle) .............................................................. 42	
  
Exercícios: ...................................................................................................................... 43	
  
 
 
 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 3 de 63 
 
Anexos ............................................................................................................................ 46	
  
Anexo A – Programação em C++ ................................................................................ 46	
  
1 - Introdução .................................................................................................................. 46	
  
2 - Fases de um Programa em C++ ................................................................................ 47	
  
3 - Estrutura de um Programa ......................................................................................... 47	
  
4 - Estrutura de uma Função ........................................................................................... 48	
  
5 - Variáveis .................................................................................................................... 48	
  
6 - Operadores Aritméticos ............................................................................................. 48	
  
7 - Operadores Relacionais ............................................................................................. 48	
  
8 - Entrada e Saída de dados ........................................................................................... 49	
  
9 - Tipos de Dados .......................................................................................................... 50	
  
10 - Estruturas ................................................................................................................. 51	
  
10.1 - Estrutura de Seleção ............................................................................................. 51	
  
10.2 - Estrutura de Seleção Encadeada ........................................................................... 51	
  
10.3 - Estrutura de Repetição While ............................................................................... 52	
  
10.4 - Estrutura de Repetição For ................................................................................... 52	
  
Anexo B – Tutorial Dev C++ ....................................................................................... 53	
  
Anexo C – Tutorial Visual Studio C ........................................................................... 60	
  
Lógica de Programação – Prof. Edgar Gurgel 
Página 4 de 63 
I - Algoritmos e Fluxogramas 
 
1 - IntroduçãoOs computadores, infelizmente, só fazem aquilo que se manda, e não 
necessariamente aquilo que se deseja que eles façam. Não deve haver ambigüidade nas 
instruções dos programas que se fornece ao computador, nem a possibilidade de 
interpretações alternativas. O computador sempre tomará algum caminho em suas 
ações, muito cuidado é necessário para se assegurar que o computador siga pelo único 
caminho correto possível que leve aos resultados desejados. Por exemplo, uma 
afirmação como: “calcule a média qualquer de notas” é muito imprecisa, apesar de 
parecer especificar aquilo que se deseja. Muitos detalhes foram omitidos, entre eles cita-
se: onde estão as notas, quantas são, os ausentes devem ou não ser incluídos, aqui está a 
essência da programação de computadores. 
 Muitos problemas interessantes parecem ser complexos do ponto de vista da 
programação. Em alguns casos (tais como problemas matemáticos difíceis), esta 
complexidade pode ser inerente ao problema em si, entretanto, em muitos casos isto 
pode ser devido a outros fatores que estão dentro do nosso controle, por exemplo, uma 
especificação incompleta ou obscura do problema. No desenvolvimento de programas, 
como será visto, a complexidade não precisa ser sempre um problema, pois a mesma 
pode ser controlada adequadamente. 
 A programação de computadores pode ser difícil. Tal dificuldade se deve a sua 
complexidade inerente, combinando muitos processos mentais. Entretanto, pode-se 
tornar mais fácil. Por exemplo, um trabalho de programação pode tornar-se muito mais 
fácil se o mesmo for dividido sistematicamente em partes menos complexas (a 
abordagem do dividir para conquistar). 
 Primeiramente, é importante separar a fase de resolução do problema da fase de 
implementação do problema. Na fase de resolução do problema, será concentrada a 
elaboração de um algoritmo para resolver um problema proposto. Somente depois da 
satisfação com a formulação de um algoritmo adequado é que se passará à 
implementação deste algoritmo em alguma linguagem de programação. Dado um 
algoritmo suficientemente preciso, sua codificação em alguma linguagem de 
programação é direta. 
Lógica de Programação – Prof. Edgar Gurgel 
Página 5 de 63 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 1.1: Resolução do Problema e Programação. 
 
2 - Conceito de Algoritmo 
Um algoritmo pode ser definido como: uma sequência finita de instruções 
bem definidas, logicamente encadeadas e não ambíguas, onde cada uma das quais 
pode ser executada mecanicamente num período de tempo finito com uma 
quantidade de esforço finito para resolver um problema do mundo real. A 
definição sugere que os algoritmos tenham diversas propriedades importantes. 
Primeiramente, os passos de um algoritmo devem ser simples e sem ambiguidade e 
devem estar numa ordem cuidadosamente definida, Além disso, se insiste em que os 
algoritmos sejam efetivos, isto é, devem sempre resolver um problema utilizando um 
número finito de passos. 
Construir algoritmos é o objetivo principal de toda a programação, portanto 
desenvolver bons algoritmos é a principal tarefa do programador. Deve-se, pois, seguir 
algumas regras básicas na resolução de um problema: 
! Compreender o problema 
• Deixar claro o problema; 
• Identificar as entradas e as saídas. 
! Delinear um plano 
• Desenvolver um procedimento para a solução do problema. 
Solução em 
forma de 
Algoritmo 
Solução como 
um programa 
de computador 
Problema 
Passo difícil 
Fase da 
resolução do 
problema 
Fase da 
implementação 
do problema 
Lógica de Programação – Prof. Edgar Gurgel 
Página 6 de 63 
! Executar o plano 
• Verificar manualmente e corrigi-lo, se necessário; 
• Codificar o algoritmo; 
• Executar o algoritmo com dados de teste, depurando quando necessário. 
! Refinar e documentar o algoritmo 
• Voltar, revisando passos; 
• Dar um tratamento estético ao algoritmo. 
 Todo algoritmo é composto por um grupo de ações primitivas (ações passíveis 
de execução por um ser humano ou por uma máquina). As ações primitivas que se 
utilizará na construção de algoritmos serão construções linguísticas em português 
(Portugol, Português estruturado ou pseudocódigo). 
O português estruturado tem como finalidade mostrar uma notação para 
elaborações de algoritmos, os quais serão posteriormente utilizados para a definição, 
criação e desenvolvimento de uma linguagem computacional. 
A diferença entre um algoritmo e uma linguagem de programação de alto nível, 
é que a primeira (escrita em português, francês, alemão, ...) não pode ser compilada em 
um computador. Isto é, quando se cria um algoritmo em Pseudocódigo, está se 
assumindo que exista um computador hipotético capaz de executá-lo. 
 
3 - Exemplos Informais de Algoritmos 
 Apesar de o termo ser novo em si, o conceito é certamente bastante familiar. As 
indicações dadas para se chegar a uma determinada rua constituem um algoritmo para 
se encontrar essa rua. Como exemplo pode-se citar: receita de cozinha, planta de 
projeto, etc. 
Por exemplo, as instruções para trocar uma lâmpada queimada são constituídas 
por uma descrição dos objetos manipulados e por uma sequência de passos. Estas 
instruções podem ser descritas como um algoritmo informal. 
 
3.1 - Exemplo 1: Troca de uma lâmpada queimada 
! Desligar o interruptor; 
! Selecionar uma nova lâmpada para a substituição; 
! Posicionar a escada embaixo da lâmpada queimada; 
Lógica de Programação – Prof. Edgar Gurgel 
Página 7 de 63 
! Subir na escada; 
! Retirar a lâmpada queimada do soquete; 
! Descer da escada; 
! Deixar a lâmpada queimada; 
! Pegar a lâmpada boa; 
! Subir na escada; 
! Colocar a nova lâmpada no soquete; 
! Descer da escada; 
! Ligar o interruptor; 
! Guardar a lâmpada queimada e a escada. 
 
4 - Exemplo de um Algoritmo 
 Para se ter noção de um algoritmo se tomará como exemplo a soma dos 100 
primeiros números inteiros positivos. O objetivo da apresentação deste exemplo é 
fornecer uma ideia intuitiva dos passos e do raciocínio envolvidos na geração de um 
algoritmo. No caso de se resolver este problema em uma calculadora, seria fornecido a 
ela a seguinte sequência de passos: 
 Limpar o visor da calculadora 
 Pressionar a tecla 1; 
 Pressionar a tecla +; 
 Pressionar a tecla 2; 
 Pressionar a tecla +; 
 Pressionar a tecla 3; 
 Pressionar a tecla +; 
 ... 
 Pressionar a tecla 100; 
 Pressionar a tecla = 
O símbolo “...” na descrição de ações acima é muito importante, pois indica que 
existe um padrão de comportamento que se repete ao longo da descrição e, portanto, 
não é necessário enumerar todos os passos, porque se pode facilmente gerar e executar 
os que estão implícitos. No entanto, a existência destes símbolos não permite qualificar 
o conjunto de instruções anteriores como um algoritmo, pois a característica da 
rigorosidade deixa de se verificar. 
Lógica de Programação – Prof. Edgar Gurgel 
Página 8 de 63 
 Para transformar as instruções anteriores num algoritmo que possa ser executado 
por um computador, é necessário tornar explícito o que está implícito. Só que para 
explicitar todos os passos do algoritmo anterior, teríamos mais trabalho do que executar 
o algoritmo propriamente dito, portanto será conveniente encontrar uma solução 
alternativa. A solução para este tipo de algoritmo será vista a seguir nas estruturas de 
controle. 
 
5 - Fluxogramas (Diagrama de Blocos) 
 É frequentemente mais fácil transmitir ideias através de ilustrações. Mapas 
fornecem uma representação conveniente da topologia da cidade, e pode ter mais valor 
quando se estáperdido do que as explicações verbais. Uma primeira tentativa no sentido 
de utilizar um formato gráfico na descrição de algoritmos, que data dos dias de Von 
Neumann, envolveu o uso de fluxogramas. Um fluxograma mostra a lógica de um 
algoritmo, enfatizando os passos individuais e suas interconexões. 
 Durante os anos um simbolismo relativamente padrão apareceu. Um cálculo é 
representado por um retângulo, uma decisão por um losango e as operações de entrada e 
saída por formas simbolizando os meios utilizados. Estes símbolos são ligados por 
linhas que indicam a ordem e o sentido em que as operações devem ser executadas. 
 Nos últimos anos, a atitude dos profissionais de programação em relação ao 
popular fluxograma diminuiu consideravelmente. A opinião sobre os fluxogramas é 
divergente. Para alguns, são considerados simplesmente um apêndice desnecessário de 
um programa; para outros, são vistos como um instigador de maus hábitos de 
programação. 
Uma nova geração de programadores está sendo educada com novos métodos de 
desenvolvimento de programas, métodos aos quais o fluxograma, adiciona muito pouco. 
Muitas vezes, quando mostra a lógica de um algoritmo, o fluxograma obscurece sua 
estrutura. Assim sendo percebeu-se que a estrutura é tão importante (e possivelmente 
mais) quanto a lógica. 
 
 
 
 
 
 
 
 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 9 de 63 
Símbolos comuns de fluxogramas 
 
 
 
Cálculo Decisão Entrada Saída 
 
 
Início / Fim Conectores 
 
Exemplo de um fluxograma 
 
 
 Início 
 
 
 nota1, nota2 
 nota3, nota4 
 
 
 
 media ← 
 (nota1 + nota2 + 
 nota3 + nota4) / 4 
 
 
 
 sim se não 
 media >= 5.0 
 
 
‘você passou com uma ‘você foi reprovado com 
 nota de’, media uma nota de’, media 
 
 
 
 
 
 
Fim 
Lógica de Programação – Prof. Edgar Gurgel 
Página 10 de 63 
Exercícios: 
1) O que é um algoritmo? E qual a sua finalidade na programação? 
2) Explique sucintamente as fases de resolução e implementação de um programa. 
3) O que é um fluxograma? E português estruturado? 
4) Usando o conceito de algoritmo informal, elabore um para mudar um pneu furado. 
Admita que estão disponíveis um macaco e um estepe em boas condições. 
5) Três senhoras, dona Branca, dona Rosa e dona Violeta passeavam pelo parque 
quando dona Rosa disse: Não é curioso que estejamos usando vestidos de cores branca, 
rosa e violeta, embora nenhuma de nós esteja usando um vestido de cor igual ao seu 
próprio nome. “Uma simples coincidência”, respondeu a senhora com o vestido violeta. 
Diga qual a cor do vestido de cada senhora? 
6) Três jesuítas e três canibais precisam atravessar um rio; para tal, dispõem de um 
barco com capacidade para duas pessoas. Por medida de segurança, não se deve permitir 
que em alguma margem a quantidade a quantidade de jesuítas seja inferior à de 
canibais. Qual a solução para efetuar a travessia com segurança? Elabora um algoritmo 
mostrando a resposta, indicando as ações que concretizam a solução deste problema. 
7) Elabore um algoritmo que mova três discos de uma Torre de Hanói, que consiste em 
três hastes (a,b,c), uma das quais serve de suporte para três para três discos de tamanhos 
diferentes (1,2,3), os menores sobre os maiores. Pode-se mover um disco de cada vez 
para qualquer haste, contanto que nunca seja colocado um disco maior sobre um menor. 
O objetivo é transferir os três discos para outra haste. 
 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 11 de 63 
II - Conceitos Básicos 
 
1 - Tipos Primitivos de Dados 
Um tipo de dado primitivo corresponde ao conjunto de valores que uma 
variável, constante, expressão ou função pode assumir e o conjunto de operações que 
podem ser efetuadas sobre ele. Estes conjuntos de valores são definidos pelas 
linguagens de programação, sobre modelos matemáticos, que aproveitam as operações 
sobre estes modelos. No caso do estudo de algoritmos, usaremos os seguintes tipos: 
• Numéricos: 
#Inteiro: toda e qualquer informação numérica que pertença ao conjunto dos 
números inteiros, isto é, dados numéricos positivos, negativos e o zero, excluindo-se 
os números fracionários. 
 #Real: toda e qualquer informação numérica que pertença aos números reais, 
isto é, o conjunto dos inteiros mais os números fracionários. 
• Não-numéricos: 
 #Caractere: toda e qualquer informação composta por apenas um dos caracteres 
alfanuméricos {0...9 }, {A...Z }ou especiais, por exemplo {%, &, <, +, #, ®, @, ...}. 
Os tipos caracteres devem ser indicados entre aspas simples (‘ ‘). 
#Cadeia: toda e qualquer informação composta por um conjunto de caracteres 
alfanuméricos e/ou especiais. Também deve ser indicado entre aspas duplas e seu 
tamanho deve ser especificado. 
 #Lógico: informação que pode assumir apenas duas situações: verdadeiro ou 
falso. Sendo que este tipo de dado poderá representar apenas um dos dois valores. 
 
2 - Constantes 
Entende-se que uma informação é constante quando não sofre variações no 
decorrer do programa. Para diferenciar as informações constantes de tipo caractere dos 
outros tipos de informação, delimitaremos por um par de aspas simples ou duplas. A 
declaração de constantes nos algoritmos será feita, por exemplo, da seguinte forma: 
const 
 preco = 45; {inteiro} 
Lógica de Programação – Prof. Edgar Gurgel 
Página 12 de 63 
resposta = ‘s’; {caractere} 
 carro = “caminhão”; {cadeia} 
pi = 3.1415; {real} 
 situacao = verdadeiro; {lógico} 
 
3 - Variáveis 
Uma informação é classificada como variável quando tem a possibilidade de ser 
alterada em algum instante no decorrer do programa. Todo dado a ser armazenado na 
memória de um computador deve ser previamente identificado, ou seja, primeiro é 
necessário saber qual o seu tipo, para depois fazer a alocação de um espaço de memória 
para o seu armazenamento adequado. 
 Em um ambiente computacional, as informações variáveis são guardadas em 
dispositivos eletrônicos chamados de memória. Esta memória pode ser vista como um 
“armário” composto de várias “gavetas”, no qual as gavetas seriam os locais físicos 
responsáveis por armazenar objetos; os objetos (que podem ser substituídos) seriam as 
informações e as gavetas seriam as variáveis. 
 Visto que na memória existem inúmeras variáveis, precisa-se diferenciá-las, o 
que é feito através do nome da variável. Cada variável, no entanto, pode guardar apenas 
uma informação de cada vez, sendo sempre do mesmo tipo. Os exemplos abaixo 
mostram como se deve declarar uma variável: 
var 
 nome,endereco: cadeia[40]; 
 apart: inteiro; 
 resposta: lógico; 
 
4 - Identificadores 
São as constantes, as variáveis e o nome do programa e servem para a sua 
identificação no programa. Os identificadores devem acompanhar as seguintes regras de 
formação: 
a) Devem começar por um caractere alfabético; 
b) Podem ser seguidos por mais caracteres alfabéticos e/ou numéricos e/ou (_); 
c) Não é permitido o uso de caracteres especiais, com exceção para o sublinhado (_); 
d) Os nomes escolhidos devem explicitar seus conteúdos; 
Lógica de Programação – Prof. Edgar Gurgel 
Página 13 de 63 
e) Os nomes escolhidos não podem ser uma palavra reservada do programa; 
Não poderá haver no mesmo programa dois identificadores com o mesmo nome, 
mesmo que representem a mesmagrandeza. 
 
5 - Expressões Aritméticas 
Denomina-se expressão aritmética aquela cujos operadores são aritméticos e 
cujos operandos são constantes e/ou variáveis do tipo numérico (inteiro e/ou real). 
 
Operadores Aritméticos 
FUNÇÃO SÍMBOLO 
Adição + 
Subtração - 
Multiplicação * 
Divisão / 
Potenciação ^ 
Quociente da divisão inteira DIV ou # 
Resto da divisão inteira MOD ou % 
 
Além das operações básicas anteriormente citadas, pode-se usar nas expressões 
aritméticas algumas funções da matemática: 
 
Funções Aritméticas (Primitivas) 
FUNÇÃO SÍMBOLO 
Retorna o seno de X SIN(X) 
Retorna o cosseno de X COS(X) 
Retorna a tangente de X TG(X) 
Retorna o arco cujo seno é X ARCSIN(X) 
Retorna o arco cujo cosseno é X ARCCOS(X) 
Retorna o arco cujo tangente é X ARCTG(X) 
Retorna o valor absoluto de X ABS(X) 
Retorna o logaritmo na base e de X LOG(X) 
Retorna o logaritmo na base 10 de X LOG10(X) 
Retorna a raiz quadrada de X SQRT(X) ou RAIZ(X) 
Retorna o quadrado de X SQR(X) ou QUAD(X) 
Arredonda o fracionário X para o inteiro superior ROUND(X) 
Arredonda o fracionário X para o inteiro inferior TRUNC(X) 
Retorna a exponencial e elevado a X EXP(X) 
Lógica de Programação – Prof. Edgar Gurgel 
Página 14 de 63 
6 - Expressões Lógicas 
Denomina-se expressão lógica aquela cujos operadores são lógicos e/ou 
relacionais e cujos operandos são relações e/ou variáveis e/ou constantes do tipo lógico. 
 
Operadores Relacionais 
 
FUNÇÃO SÍMBOLO 
Igual a = 
Diferente de <> 
Maior que > 
Menor que < 
Maior ou igual que >= 
Menor ou igual que <= 
 
Utilizar-se-á quatro conectivos básicos para a formação de novas preposições a 
partir de outras já conhecidas. Os operadores lógicos são: 
 
Operadores Lógicos 
FUNÇÃO SÍMBOLO 
Conjunção E 
Disjunção não-exclusiva Ou 
Negação Não 
 
Tabelas Verdade 
Tabela Verdade é o conjunto de todas as possibilidades combinatórias entre os 
valores de diversas variáveis lógicas, as quais se encontram em apenas duas situações, e 
um conjunto de operadores lógicos. 
• Negação (~) ⇔ Conectivo não: 
A Não A 
Verdadeiro Falso 
Falso Verdadeiro 
 
• Conjunção (^) ⇔ Conectivo e : 
A B A e B 
Verdadeiro Verdadeiro Verdadeiro 
Verdadeiro Falso Falso 
Falso Verdadeiro Falso 
Falso Falso Falso 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 15 de 63 
• Disjunção (v) ⇔ Conectivo ou: 
A B A ou B 
Verdadeiro Verdadeiro Verdadeiro 
Verdadeiro Falso Verdadeiro 
Falso Verdadeiro Verdadeiro 
Falso Falso Falso 
Durante a execução de uma expressão que envolve vários operadores, é 
necessária a existência de prioridades, caso contrário poderemos obter valores que não 
representam o resultado esperado. É a seguinte a hierarquia que deve ser seguida: 
1. Efetuar as operações embutidas em parênteses mais internos 
2. Efetuar funções matemáticas 
3. Efetuar potenciações 
4. Efetuar as multiplicações e/ou divisões 
5. DIV e/ou MOD 
6. Efetuar adição e/ou subtração 
7. Operadores relacionais 
8. Operadores lógicos 
8.1. não 
8.2.e / ou 
 
7 - Comando de Atribuição 
 Um comando de atribuição permite fornecer um valor a uma certa variável 
(guardar um objeto em uma gaveta), onde o tipo dessa informação deve ser compatível 
com o tipo de variável, isto é, somente podemos atribuir um valor inteiro a uma variável 
capaz de comportá-lo, ou seja, uma variável declarada do tipo inteiro. Exemplos: 
 total ← 34; 
 resposta ← verdadeiro; 
 time_bom ← “Flamengo”; 
 A característica principal das variáveis é a de que podem guardar valores 
diferentes em tempos diferentes. A habilidade de modificar os valores das variáveis é 
muito importante, por isso, às vezes, pode-se verificar a presença de mesma variável em 
ambos os lados da linha de atribuição. Considere que esta aparição em ambos os 
membros têm significados diferentes no processamento do comando. 
Lógica de Programação – Prof. Edgar Gurgel 
Página 16 de 63 
No exemplo abaixo, o primeiro valor que a variável X alocará será 1, no 
segundo momento este valor passará a ser 2. O primeiro valor será perdido e o segundo 
valor continuará alocado na memória, até que haja uma nova atribuição a esta variável. 
Por isso que se diz que o comando de atribuição é uma operação destrutiva, pois 
qualquer valor que a variável possuía antes do processamento da operação de atribuição 
se perde, sendo substituído pelo novo valor. O exemplo mostra a função da variável em 
cada um dos lados. 
 x ← 1; 
 x ← x + 1; 
 
 
 
 
 
8 - Entrada e Saída de Dados 
Os cálculos do computador não são de grande valor a não ser que, primeiro, se 
possa fornecer os dados sobre os quais estes cálculos serão efetuados e, segundo, ver os 
resultados desses cálculos. Uma vez que as operações de entrada e saída são muito 
relacionadas à interação dos programadores, sua forma é altamente dependente da 
linguagem de programação específica utilizada e, às vezes, do próprio sistema de 
computador. 
Todo algoritmo para computador possui comandos que levam a informação da 
memória principal do computador a seus periféricos e vice-versa. Os comandos que se 
fará uso para manusear entrada e saída de informações são mostrados a seguir: 
leia(lista de entrada) 
A lista de entrada nos dá os nomes das variáveis às quais os valores devem ser 
atribuídos. 
O comando ler permite ler valores dados atribuindo-os a variáveis indicadas. Há 
de se ressaltar que o processo de associar valores às variáveis indicadas é semelhante à 
operação de atribuição em dois importantes aspectos: 
• Qualquer valor que a variável possua anteriormente será destruído; 
• Como na atribuição, é verificada a compatibilidade de tipo. 
Indica que um 
segundo valor 
será atribuído à 
variável x 
Indica que o 
primeiro valor 
da variável x 
será utilizado 
Lógica de Programação – Prof. Edgar Gurgel 
Página 17 de 63 
O exemplo abaixo demonstra tais aspectos: 
var 
a,b: inteiro; 
 b ← 1; 
 leia(a,b);{valores de a e x lidos são 3 e 4} 
 leia(a); {valor de a lido seja 10} 
 
 Nota-se, ao executar o exemplo acima, que o valor final de a será 10, pois o 
outro valor (3) foi destruído, devido a ordem de execução dos comandos e que o valor 
de b será 4 pelo mesmo motivo. 
escreva(lista de saída) 
 O comando de saída é semelhante ao comando de entrada em formato, porém 
um pouco mais geral em termos do que se pode especificar na lista de saída. É possível 
mostrar: 
• O conteúdo de qualquer variável; 
• O resultado de qualquer expressão; 
• O valor de qualquer constante. 
 
Seguem alguns exemplos: 
 
escreva(total); 
escreva(valor1, valor2, media); 
escreva(“Bom Dia!”, nome); 
escreva(“Você pesa”, x*2, “quilos”); 
 
9 - Blocos 
 Um bloco pode ser definido como um conjunto de ações com uma função 
definida; neste caso, um algoritmo pode ser visto como um bloco. Delimita-se o bloco 
por um início e um fim. 
 início 
 . 
 . {seqüência de ações} 
 . 
 fim. 
Lógica de Programação – Prof. Edgar Gurgel 
Página 18 de 63 
 
Exercícios: 
8) Determine o valor atribuído a variável A: 
1. A ← 3 ^ 3 + 4 * 8 / 5 + 2 * 4 
2. B ← 16 - 12 / 3 
 C ← 3 
 A ← B div C + (B - 2 * C) mod C 
 
9) Determine o valor de X nas expressões: 
1. A ← 2 
 X ← 6 - SQRT (2 ^ A) * 5 - 4 * (18 - 4 ^ 2) 
2. A ← 2 
 B ← 4 
 X ← ((28 + 3 * B) / A - (A ^ B)) * 3 * 2 
 
10) Determine o resultado(falso ou verdadeiro) das seguintes expressões lógicas: 
1. não (X mod Y > 13) e não (Y > 22), para X=14 e Y=3 
2. não DIAUTIL ou ((HORASDIA > 8) e não (HORASTOT div HORASDIA > 
21)), para DIAUTIL = falso, HORASDIA = 4 e HORASTOT = 22Lógica de Programação – Prof. Edgar Gurgel 
Página 19 de 63 
III - Estrutura de Sequência 
 
1 - Introdução 
Na criação de algoritmos, serão utilizados os conceitos de bloco lógico, entrada 
e saída de dados, variáveis, constantes, atribuições, expressões lógicas, relacionais e 
aritméticas, bem como comandos que traduzam estes conceitos de forma a representar o 
conjunto de ações. 
Para que esse conjunto de ações se torne viável, deve existir uma perfeita relação 
lógica intrínseca ao modo pelo qual essas ações são executadas, ao modo pelo qual é 
regido o fluxo de execução. 
Através das estruturas básicas de controle do fluxo de execução – sequência, 
seleção, repetição – e da combinação delas, pode-se criar um algoritmo para solucionar 
qualquer problema. 
 
2 - Conceito de Sequência 
 Sequência é um conjunto de ações primitivas que serão executadas numa 
sequência linear de cima para baixo, isto é, serão executadas na mesma ordem em que 
foram escritas. As ações devem sempre ser seguidas por ponto-e-vírgula(;), que objetiva 
separar uma instrução da outra e auxiliar organização sequencial das ações, pois após 
encontrar um (;) deve-se executar o próximo comando da sequência. 
 
3 – Exemplos 
 
Exemplo 1: Uma loja de móveis está promovendo uma liquidação anual. Deve-se 
desenvolver um programa para calcular o preço total, para o cliente de um item que terá 
certa redução percentual (desconto) sobre seu preço de lista. 
 Para se resolver este problema, o primeiro passo é procurar entendê-lo. Do modo 
como foi feito, o enunciado do problema é muito geral. Por exemplo, poder-se fazer as 
seguintes perguntas: 
• Todos os itens terão o mesmo desconto? 
• O que é incluído no preço total para o cliente? 
• Devem ser incluídos impostos? Neste caso a que taxa? 
Lógica de Programação – Prof. Edgar Gurgel 
Página 20 de 63 
 Um programador deve tomar decisões a respeito da fonte e natureza dos dados 
de entrada, da saída desejada, do grau de precisão e assim por diante. Programadores 
profissionais geralmente tomam essas decisões discutindo com os futuros usuários do 
programa. 
 Neste problema, descobriu-se que a redução percentual (o desconto) sobre o 
preço de lista é diferente de item para item. O preço total para o cliente incluirá o preço 
com desconto, mais uma taxa de imposto fixo de 5% sobre esse preço. No entanto, os 
usuários do programa querem que seja também calculada a quantia economizada como 
o resultado do desconto. Temos, pois, que fornecer ao programa informações relativas 
ao preço do item e à percentagem de desconto. 
 O programa, então, dará informações relativas à quantia economizada e preço 
total para o cliente. Mais a título de metodologia serão utilizadas algumas regras para 
desenvolver este primeiro programa. 
 
# REGRA 1 # 
 A primeira declaração em um programa serve para lhe dar um nome, este é 
facultativo, mas sempre obedecendo às regras dos identificadores. Esta primeira 
declaração marca o seu ponto inicial. Exemplo: 
Algoritmo PRECO_VENDA; 
 
# REGRA 2 # 
 Logo após o nome do programa vem a declaração das constantes, se nele houver. 
Todas as constantes a serem usadas no programa recebem os seus valores pré-definidos. 
Exemplo: 
const 
 taxa_imp = 0.05; 
 
# REGRA 3 # 
 Depois disto vem a declaração das variáveis a serem usadas no programa. O 
nome e também o tipo das variáveis devem ser declarados. 
A regra 3 requer o desenvolvimento de um procedimento para resolver o 
problema. Isto é, as incógnitas (variáveis de saída) devem ser determinadas por algum 
tipo de manipulação de dados (variáveis de entrada). Para encontrar essas variáveis, 
pode-se dividir o trabalho em três tarefas principais: 
Lógica de Programação – Prof. Edgar Gurgel 
Página 21 de 63 
• Obter informações relativas ao preço de lista e desconto (fornecer os dados de 
entrada); 
• Calcular a economia e o preço total; 
• Gerar a saída do programa (os resultados esperados: preço total e economia). 
 
var 
preco_lista, taxa_desc, economia, 
 preco_red, preco_total: real; 
 
# REGRA 4 # 
 O início da seção de procedimentos de todo programa é marcado por início. 
A entrada e saída de variáveis são expressas genericamente, sem referência a 
dispositivos específicos de E/S (como terminal de vídeo, impressora, teclado, disco,...). 
O procedimento para a entrada de dados será o seguinte: primeiramente será 
mandada uma mensagem para o usuário através do comando escrever, por exemplo: 
escreva(“Entre com o preço da lista:”); 
Em seguida será utilizado o comando ler para colocar o valor que o usuário 
digitou na memória do computador. Significa que o programa deve receber um valor 
para a variável. 
leia(preco_total); 
 Para exibir o valor de preco_total será utilizado novamente o comando escrever, 
que significa que este valor será mostrado em algum dispositivo de saída, neste caso o 
vídeo. 
escreva(“O preço total calculado foi:”, preco_total); 
O comando escrever também pode exibir constantes em formas de mensagem, 
como por exemplo: 
escreva(“Este programa calcula o preço reduzido”); 
 
# REGRA 5 # 
 As variáveis receberão novos valores dentro do programa, por meio de operação 
de atribuição ←. 
Para processar a informação de entrada, a fim de obter a saída, deve-se dispor de 
algum método para calcular e armazenar o valor de uma expressão. Por exemplo, para 
Lógica de Programação – Prof. Edgar Gurgel 
Página 22 de 63 
calcular a variável economia, é precisa multiplicar a variável preço de lista pela 
percentagem de desconto (expressa como um valor decimal). Isto pode ser escrito: 
economia ← preco_lista * (taxa_desc / 100); 
 O comando acima pode ser lido como: “economia recebe o valor de preco_lista 
multiplicado por taxa_desc dividido por cem”. 
 
# REGRA 6 # 
 O fim de todo o programa é marcado por um fim. 
 
 Combinando todos esses comandos, o programa pode ser expresso, em 
linguagem algorítmica, como se segue: 
 
Algoritmo preco_venda; 
const 
 taxa_imp = 0.05; 
var 
preco_lista, taxa_desc, economia, 
 preco_red, preco_total: real; 
inicio 
escreva(“Entre com o preço da lista:”); 
 leia(preco_lista); 
 escreva(“Entre com o desconto percentual:”); 
 leia(taxa_desc); 
 economia ← preco_lista * (taxa_desc / 100); 
 preco_red ← preco_lista - economia; 
 preco_total ← preco_red + preco_red * taxa_imp; 
 escreva(“A economia é:”, economia); 
 escreva(“O preço total é:’, preco_total); 
fim. 
 
 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 23 de 63 
Exercícios: 
11) Construir um algoritmo para calcular a média aritmética entre duas notas 
quaisquer fornecidas pelo usuário. 
 
12) Dados os lados de um triângulo retângulo (nas variáveis Lado1 e Lado2), 
determine e exiba o comprimento do terceiro lado (hipotenusa). Supõe-se que todas 
as variáveis sejam inteiras. 
 
13) Preparar um algoritmo para ler uma temperatura dada na escala Celsius e exibir o 
equivalente na escala Fahrenheit (fórmula de conversão: F= 9 / 5 * C + 32). 
 
14) Ler dois valores para as variáveis A e B, efetuar a troca dos valores de forma que 
a variável A passe a possuir o valor da variável B e que a variável B passe a possuir o 
valor da variável A. Apresentar os valores trocados. 
 
15) Preparar um algoritmo para efetuar o cálculo de quantidade de litros de 
combustível gasta em uma viagem, utilizando-se um automóvel que faz 12 KM por 
litro. Para obter o cálculo, o usuário deverá fornecer o tempo gasto na viagem e a 
velocidade média durante a mesma. Desta forma, será possível obter a distância 
percorrida com a fórmula: distancia = tempo * velocidade. Tendo o valor da distância, 
basta calcular a quantidadede litros de combustível utilizada na viagem com a 
fórmula: litros = distancia / 12. O programa deverá exibir o valor da quantidade de litros 
de combustível utilizada na viagem. 
 
16) Elaborar um algoritmo para ler dois valores inteiros e efetuar as operações de 
adição, subtração, multiplicação e divisão do primeiro pelo segundo, apresentando no 
final os quatro resultados obtidos. 
 
17) Preparar um algoritmo para ler os valores dos coeficientes a, b, c de uma equação 
quadrática da forma: ax2 + bx + c e exibir o valor do discriminante. 
 
18) O cardápio de uma casa de hambúrguer é dado abaixo. Preparar um algoritmo 
para ler a quantidade de cada item comprado e calcular a conta final. 
 Casa de hambúrguer 
Hambúrguer R$ 4,20 
Cheeseburger R$ 4,50 
Batata frita R$ 3,80 
Milkshake R$ 5,80 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 24 de 63 
IV - Estrutura de Seleção 
 
1 - Conceito de Seleção 
 Apesar de se conseguir solucionar problemas e transformá-los em programas, os 
recursos da estrutura sequencial são muito limitados, pois haverá momentos em que um 
determinado valor dentro de um programa necessitará ser tratado para se efetuar um 
processamento mais adequado. 
 Uma estrutura de seleção permite a escolha de um grupo de ações e estruturas a 
ser executado quando determinadas condições, representadas por expressões lógicas, 
são ou não satisfeitas. 
 Deve-se imaginar a seguinte situação: um programa que apresente a média 
escolar de um aluno. Até aqui, muito simples, mas além de calcular a média, o 
programa deve apresentar se o mesmo está aprovado ou reprovado segundo a análise de 
sua média. Deve-se observar que aqui será necessário verificar a média do aluno para 
então se tomar uma decisão no sentido de apresentar a sua real situação: aprovado ou 
reprovado. 
 
2 - Seleção Simples 
Sintaxe da estrutura: 
Se <condição> 
 Então 
 inicio 
 instrução 1; 
 instrução 2; 
 . 
 . 
 . 
 instrução n; 
 fim; {fim do então} 
fim-se; 
<condição> é uma expressão lógica, que quando verificada, pode gerar um 
resultado falso ou verdadeiro. 
Lógica de Programação – Prof. Edgar Gurgel 
Página 25 de 63 
 Se <condição> for verdadeira, então o “bloco verdade” (Então) será executado; 
caso contrário (<condição> for falsa) o comando será encerrado. 
 Verificar-se-á, agora, o seguinte exemplo, para se analisar a estrutura alternativa 
simples: 
 
Algoritmo notas1; {Calcula a média aritmética entre duas 
notas e verifica se o aluno foi aprovado por média} 
var 
n1,n2,media: real; 
inicio 
 leia(n1); 
 leia(n2); 
 media ←(n1 + n2)/2; 
 escreva(“A média foi =”, media); 
 Se media >= 8 
 Então 
 escreva(“Aprovado por média”); 
 fim-se; 
fim. {término do algoritmo} 
 
3 - Seleção Composta 
Sintaxe de estrutura: 
Se <condição> 
 Então 
 Início 
 instrução 1; 
 instrução 2; 
 . 
 . 
 instrução n; 
 fim 
 Senão 
 inicio 
 instrução 1; 
Lógica de Programação – Prof. Edgar Gurgel 
Página 26 de 63 
 instrução 2; 
 . 
 . 
 instrução n; 
 fim; 
fim-se; 
 
Se a condição for satisfeita, então apenas o “bloco verdade” será executado, caso 
contrário, o “bloco falso” é o que será executado. 
 
Exemplo 1: Construir um algoritmo para calcular as raízes de uma equação do 2º grau. 
Algoritmo equacao;{calcula as raízes da equação} 
var 
x1,x2,delta,a,b,c: real; 
Início 
 escrever(“Entre com os valores dos coef. a, b e c:”); 
 leia(a); 
 leia(b); 
 leia(c); 
 delta ← b^2 - 4*a*c; 
 Se delta > 0 
 Então 
 inicio 
 x1 ← (-b + SQRT(delta)) / 2 * a; 
 x2 ← (-b - SQRT(delta)) / 2 * a; 
 escreva(“raiz 1=”,x1, “raiz 2=”,x2); 
 fim 
 Senão 
 escreva(“Não existem raízes reais!”); 
 fim-se; 
fim. 
 
 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 27 de 63 
Exemplo 2: Melhorar o exemplo do cálculo da média das notas: 
Algoritmo notas2;{Calcula a média aritmética entre duas 
notas e verifica se o aluno foi aprovado por média} 
var 
n1,n2,media: real; 
inicio 
 leia(n1); 
 leia(n2); 
 media ←(n1 + n2)/2; 
 escrever(“A média foi =”, media); 
 Se media >= 8 
 Então 
 escreva(“Aprovado por média”); 
 Senão 
 escreva(“Prova Final”); 
 fim-se; 
fim. {término do algoritmo} 
 
4 - Seleção Encadeada ou Aninhada (Se´s encaixados) 
 Pode-se agrupar várias alternativas a fim de inspecionar uma ou mais condições. 
Geralmente tal estrutura é formada quando uma determinada instrução ou bloco de 
ações deve ser executado se um conjunto de possibilidades ou combinações de situações 
for satisfeito. 
Sintaxe da estrutura: 
Se <condição 1> 
 então 
 instrução 1 
 senão 
 Se <condição 2> 
 então 
 inicio 
 instrução 2; 
 instrução 3; 
Lógica de Programação – Prof. Edgar Gurgel 
Página 28 de 63 
 instrução 4; 
 fim 
 senão 
 Se <condição 3> 
 então 
 instrução 5; 
 fim-se; 
 fim-se; 
fim-se; 
 
Se <condição 1> for satisfeita, então a instrução 1 será executada, caso contrário, 
a <condição 2> será inspecionada e se for satisfeita, então o bloco de ações (instrução 2, 
instrução 3, instrução 4) será executado, caso contrário a <condição 3> será verificada e 
se for satisfeita, a instrução 5 será executada. 
 
5 - Seleção de Múltipla Escolha (Estrutura Caso) 
 Quando uma única variável pode assumir diversos valores e que as instruções a 
serem executadas dependam do valor armazenado nesta variável, pode-se usar a 
estrutura Caso. Seria uma forma mais compacta da Seleção encadeada. 
Sintaxe da estrutura: 
Caso <variável> faça 
 v1: instrução 1; 
 v2: 
 inicio 
 instrução 2; 
 instrução 3; 
 instrução 4; 
 fim; 
 Senão 
inicio 
 instrução 7; 
 instrução 8; 
fim; {fim do bloco senão} 
fim; {fim da estrutura Caso} 
Lógica de Programação – Prof. Edgar Gurgel 
Página 29 de 63 
 
Exemplo: Construa um algoritmo que, tendo como dados de entrada o preço de um 
produto e um código de origem, emita o preço junto de sua procedência. Caso o código 
seja nenhum dos especificados, o produto deve ser encarado como importado. 
Código de Origem: 
1- Sul 
2- Norte 
3- Leste 
4- Oeste 
 
Algoritmo produto; 
var 
 preco: real; 
 origem: inteiro; 
inicio 
 leia(origem); 
 leia(preco); 
 Caso origem faça 
 1: escreva(preco, “Produto do Sul”); 
 2: escreva(preco, “Produto do Norte”); 
 3: escreva(preco, “Produto do Leste”); 
 4: escreva(preco, “Produto do Oeste”); 
 senão 
 escreva(preco, “Produto Importado”); 
 fim; 
fim. 
 
Exercícios 
19) Faça um algoritmo para ler um número e se ele for maior do que 20 então exibir a 
metade desse número. 
20) Faça um algoritmo para ler um número e informar se ele é positivo, negativo ou 
nulo. 
Lógica de Programação – Prof. Edgar Gurgel 
Página 30 de 63 
21) Faça um algoritmo para realizar as quatro operações básicas. Considere que 
serão lidos dois números como entrada e os seguintes caracteres representando as 
operações básicas: + (adição), - (subtração), * (multiplicação) e / (divisão). Você deve 
considerar ainda a possibilidade do usuário digitar um valor diferente das operações 
básicas descritas acima, e neste caso o algoritmo deve escrever uma mensagem 
informando “Caractere inválido”. 
22) Faça um algoritmo para ler dois números e efetuar a adição destes números. Caso 
o valor somado seja maior que 20 este deverá ser apresentado somando-se a ele 
mais 8, caso o valor somado seja menor ou igual a 20 este deverá ser apresentado 
subtraindo-se 5. 
23) A Prefeitura do Rio abriu uma linha de crédito para os funcionários estatutários. O 
valor máximo da prestação não poderá ultrapassar 30% do saláriobruto. Faça um 
algoritmo que permita entrar com o salário bruto e o valor da prestação e informar se o 
empréstimo pode ou não ser concedido. 
24) Faça um algoritmo para entrar com um número e exibir se ele é maior do que 20, 
menor ou igual a 20. 
25) Faça um algoritmo para entrar com dois números e exibir o maior número, 
supondo que são diferentes. 
26) Faça um algoritmo para entrar com três números e exibir o maior número, supondo 
que são diferentes. 
27) Faça um algoritmo para entrar com três números e armazenar o maior número na 
variável de nome maior, supondo que são diferentes. Exiba o maior número. 
28) Faça um algoritmo para ler três números, os possíveis lados de um triângulo, e 
exibir a classificação segundo os lados: equilátero, escaleno e isósceles. Verifique 
antes se os lados formam um triângulo, em caso negativo, informe ao usuário. 
29) Um comerciante comprou um produto e quer vendê-lo com um lucro de 45% se o 
valor da compra for menor que R$ 20,00. Caso contrário, o lucro será de 30%. Faça 
um algoritmo para ler o valor do produto e exibir o valor da venda. 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 31 de 63 
30) Faça um algoritmo para entrar com o salário de uma pessoa e exibir o desconto do 
INSS segundo a tabela a seguir: 
Menor ou igual a R$ 600,00 Isento 
Maior que R$ 600,00 e menor ou igual a R$ 1200,00 20% 
Maior que R$ 1200,00 e menor ou igual a R$ 2000,00 25% 
Maior que R$ 2000,00 30% 
 
31) Faça um algoritmo para ler a nota de um aluno e converta esta nota quantitativa 
em uma nota qualitativa, de acordo com a tabela abaixo: 
Nota quantitativa Nota qualitativa 
nota<=2 Sem rendimento 
nota>2 a 4 Mau 
nota>4 a 6 Regular 
nota>6 a 8 Bom 
nota>8 a 10 Excelente 
 
 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 32 de 63 
V – Função 
 
5.1 Conceito 
 
Função é um trecho de programa com atribuições específicas, 
simplificando o entendimento do programa, proporcionando ao programa 
menores chances de erro e de complexidade. 
A linguagem C é formada de várias funções. 
 
5.2 Vantagens 
 
As funções através da passagem de parâmetros e através do seu nome 
permitem que sejam retornados valores à rotina chamadora e desta 
forma, esses valores poderão ser impressos, atribuídos a uma variável 
ou podem servir em operações aritméticas entre outras. 
 
Os principais objetivos de uma função são: 
• Dividir e estruturar um algoritmo em partes logicamente 
coerentes; 
• Facilidade em testar os trechos em separados; 
• O programador poderá criar sua própria biblioteca de funções, 
tornando sua programação mais eficiente uma vez que poderá 
fazer uso de funções por ele escritas em vários outros programas 
com a vantagem de já terem sido testadas; 
• Aumentar a legibilidade de um programa; 
• Evitar que uma certa sequência de comandos necessária em 
vários locais de um programa tenha que ser escrita repetidamente 
nestes locais, diminuindo também, o código fonte,; 
 
Tudo isto justifica o uso de funções em nossos programas. 
 
5.3. Funções Pré-definidas 
 
O conjunto de funções pré-definidas é muito extenso e aqui vamos 
relacionar algumas funções das bibliotecas: math, ctype, string e stdlib. 
Quando estudamos uma função, temos vários parâmetros a observar. 
Veja, por exemplo a seguinte função pré-definida da biblioteca math: 
 
double sqrt(double x) 
 
Este é o protótipo da função, isto é, informações sobre o nome da 
função, o tipo de retorno da função e tipos dos parâmetros. 
Esta função retorna um valor double, seu nome é sqrt e o tipo da 
variável que recebe o valor passado(parâmetro) é double. 
Lógica de Programação – Prof. Edgar Gurgel 
Página 33 de 63 
Quando você criar suas funções, elas precisarão ter uma declaração 
semelhante a esta. 
As funções poderão ser localizadas antes da função principal(main) ou 
depois. 
Se uma função for declarada antes, o protótipo da função não precisará 
ser declarado na função main, mas se declarada depois, o protótipo precisará 
ser declarado na função main. 
 
Declaração de uma função: 
tipo identificador (lista de parâmetros) 
int, float, char, void Nome da função ( tipo1 nome1, tipo2 nome2 ) 
 
Exemplos: 
int quadrado(int l) 
char maiuscula(char n[] ) 
 
 
5.4 Chamada da função 
 
Não devemos ficar preocupados como isso irá acontecer, pois já fizemos 
uso de vários funções internas(funções do tradutor) e, da mesma forma, 
chamaremos as nossas funções. 
Quando uma função é chamada, o fluxo de controle é desviado para a 
função, no momento em que ela é ativada no programa principal. Ao terminar 
a execução dos comandos da função, o fluxo de controle retorna ao comando 
seguinte àquele onde ela foi ativada, exatamente como na figura abaixo: 
 
 
 
 
5.5 Estrutura de uma função 
 
Uma função é um bloco contendo início e fim, sendo identificada por um 
nome , pelo qual será referenciada em qualquer parte e em qualquer momento 
do programa. A função serve para executar tarefas menores como ler, calcular, 
main() funcao1( ...) 
{ ... 
 retorna(...); 
} 
{... 
... 
< chamada da função 1 > 
... 
... 
} 
Lógica de Programação – Prof. Edgar Gurgel 
Página 34 de 63 
determinar o maior/menor valor entre uma lista de valores, ordenar, converter 
para maiúsculas, entre outras. 
Após executar estas tarefas menores, a função retorna, ou não, um 
determinado valor para a função chamadora. 
Quando a função não retornar nada(nulo) usaremos o tipo void, pois é 
sugerido pelo comitê de padronização ANSI. 
Dentro da função, podem ser declaradas variáveis que chamamos 
de variáveis locais, pois só são visíveis dentro da função. 
 
Sintaxe da função: 
 
<tipo de função> nome_da_função(declarações dos parâmetros) 
{ 
 < declaração das variáveis locais> 
 comandos que formam o corpo da função 
 return(< valor >) ; /* ou return; ou nada */ 
} 
 
tipo de função : tipo de dado que a função dará retorno. Pode ser int, float, char ou void 
nome da função : segue as mesmas regras de declaração de 
variáveis 
parâmetros : nomes das variáveis, seguem as mesmas regras de declaração de variáveis 
declarações dos 
parâmetros 
: declarações de variáveis da função(tipo e nome) 
{ : início da função 
variáveis locais : declarações de variáveis que serão utilizadas 
dentro da função( tipo e nome) 
corpo da função : sequência de comandos 
return( .. ) : o que vai ser retornado para o algoritmo ou não 
existe 
} : fim da função 
 
 
5.6 Localização das funções 
 
Podem ser colocadas antes ou após a função principal (main). 
protótipo da funcao1; 
protótipo da funcao2; 
protótipo da funcao3; 
 
int main() 
{ 
... 
} 
Lógica de Programação – Prof. Edgar Gurgel 
Página 35 de 63 
// abaixo do main() 
// definição de função 
funcao1(...) 
{ 
 ... 
} 
 
funcao2(...) 
{ 
 ... 
} 
 
funcao3(...) 
{ 
 ... 
} 
 
5.7 Dividindo o programa em funções 
 
Nós podemos modularizar nossos programas para que possamos deixá-
lo mais claro. Se as funções manipulam as mesmas variáveis, deveremos 
declará-las com variáveis globais, isto é, fora de todas as funções. 
 
5.8 Tipos de Funções 
 
5.8.1 Funções void ( não retornam nada) 
 
Este tipo de função não tem nenhum dado de retorno para a função 
principal. Ela executa o trecho e retorna para a função seguinte da sua 
chamada. A função pode não ter parâmetros e ser do tipo void, também. 
Exemplo: 
#include <iostream> 
using namespace std; 
void aster();/*prototipo da função(tipo de retorno, nome e (argumentos) */ 
 
int main() 
{ 
 cout<<"\nAlgoritmo\n"; 
 aster(); 
 cout<<"\nLogica\n"; 
 aster(); 
 system(“pause”);} 
 
void aster() 
{ 
 cout<<"***************************************************************************"; 
} 
Lógica de Programação – Prof. Edgar Gurgel 
Página 36 de 63 
 
5.8.1 Funções com passagem de valor 
 
A linguagem C++ passa os valores para funções através de argumentos 
das chamadas das funções para os parâmetros das funções, na verdade 
variáveis que receberão cópias dos dados. Desta maneira, os dados de origem 
não são alterados. 
Uma boa dica: Suponha que você comprou um livro e descobriu alguns 
erros. Você corrige no seu livro, mas não altera o original que, enquanto o autor 
não corrigir, os erros permanecerão. 
 
A única exceção é para as matrizes que são ponteiros para o primeiro 
elemento da matriz. 
 
Exemplo: Função para somar dois números 
#include <iostream> 
using namespace std; 
void soma(int x, int y); /*protótipo função(tipo de retorno, nome e(argumentos) */ 
int main() 
{ 
 int num1,num2; 
 cout<<”Digite o primeiro numero:”; 
 cin>>num1, 
 cout<<”Digite o segundo numero:”; 
 cin>>num2, 
 soma(num1,num2); 
 system("pause"); 
} 
 
void soma(int x, int y) 
{ 
 int soma; 
 soma = x + y; 
 cout>>”\n A soma e <<soma; 
} 
 
 
 
 
 
 
 
 
 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 37 de 63 
Exercícios 
32) Desenvolva um programa que tenha três funções: uma para calcular e 
apresentar a subtração, uma para a multiplicação e uma para a divisão de dois 
números quaisquer fornecidos pelo usuário. Os números devem ser fornecidos 
no programa principal e depois informados à função que realiza a operações e 
exibe o resultados. 
33) Desenvolva um programa que tenha uma função para calcular e apresentar 
o valor de uma potência de um número qualquer informado pelo usuário. Ou 
seja, ao informar para a função o número e a sua potência, deve ser 
apresentado o seu resultado. Por exemplo, se for mencionado no programa 
principal à função potência(2,3), deve ser apresentado o valor 8. 
 
 
 
 
 
 
 
 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 38 de 63 
VI - Estrutura de Repetição 
 
1 - Conceito de Repetição 
 Na estrutura de sequência sabe-se que os comandos são executados uma única 
vez e um após o outro (de cima para baixo). Com o estudo da seleção, acrescenta-se a 
possibilidade de escolher instruções a serem executadas, mas cada instrução continua 
sendo executada apenas uma vez. A execução do programa começa com a primeira 
instrução e termina na última, sendo cada instrução executada no máximo uma vez. Em 
programação é frequentemente preciso repetir a execução de um grupo de instruções, ou 
mesmo repetir a execução de todo o programa, para diferentes valores de dados. 
 Em programação, uma sequência de instruções executada repetidas vezes é 
chamada de laço(loop). Um laço é constituído por uma sequência de instruções, o corpo 
do laço, e por uma estrutura que controla a repetição deste corpo, especificando quantas 
vezes ele terá de ser repetido. 
 As instruções que constituem o corpo de um laço podem ser executadas qualquer 
número de vezes(até mesmo nenhuma), mas este número é finito. Há erros semânticos 
que podem provocar a execução interminável do corpo do laço, caso que se diz que o 
laço é infinito. 
 Existem três estruturas que permitem a especificação de laços em nossa 
linguagem algorítmica: Enquanto, Repita e Para. 
 
2 - Enquanto (Repetição com Teste no Início) 
 Consiste numa estrutura de controle de fluxo que permite executar de forma 
repetitiva uma instrução (ou bloco de instruções) enquanto uma determinada expressão 
lógica tiver o valor verdadeiro, porém, sempre verificando antes de cada execução se é 
permitido repetir o mesmo trecho. 
Sintaxe da estrutura: 
Enquanto <condição> faça 
 Início 
 instrução 1; 
 instrução 2; 
 instrução 3; 
Lógica de Programação – Prof. Edgar Gurgel 
Página 39 de 63 
 . 
 . 
 . 
 instrução n; 
 fim; {fim do enquanto} 
 
Enquanto a condição for satisfeita, as instruções de 1 a n serão repetidas, caso 
contrário, o comando é abandonado (sai do laço). Se já da primeira vez o resultado for 
falso, os comandos não serão executados uma única vez. 
 A estrutura Enquanto pode ser usada para construir laços determinados ou 
indeterminados. Seguem alguns exemplos de como estes tipos de laços funcionam: 
 
Exemplo1: Número de repetições determinadas: Construir um algoritmo para calcular a 
soma dos 100 primeiros números inteiros e positivos. 
Algoritmo soma100; 
var 
 numero,soma: inteiro; 
inicio 
 soma ← 0; 
 numero ←1; 
Enquanto (numero <= 100) faça 
início 
 soma ← soma + numero; 
 numero ← numero + 1; 
fim; 
escreva(“Soma:”, soma); 
fim. 
 
Exemplo2: Número de repetições indeterminadas (uso do finalizador ou flag): 
Construir um algoritmo que, dado um conjunto de valores reais, determinar o maior 
valor do conjunto. O valor 0 (zero) é usado como finalizador. 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 40 de 63 
Algoritmo maior_elemento; 
var 
 valor, maior: real; 
inicio 
 escreva(“Entre com o valor =”); 
 leia(valor); 
 maior ← valor; 
Enquanto (valor <> 0) faça 
 início 
 Se valor > maior 
 Então 
 maior ← valor; 
 escrever(“Entre com o valor =”); 
 leia(valor); 
 fim; 
 escreva(“Maior valor =”,maior); 
fim. 
 
3 - Repita (Repetição com Teste no Final) 
 Consiste numa estrutura que permite que um bloco ou uma ação primitiva seja 
repetida até que uma determinada condição seja satisfeita. 
Sintaxe da estrutura: 
Repita 
 instrução 1; 
 instrução 2; 
 instrução 3; 
 . 
 . 
 . 
 instrução n; 
Até <condição>; 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 41 de 63 
 A diferença básica entre as estruturas enquanto e repita é que nesta última, o 
bloco é executado pelo menos uma vez independentemente da validade da condição, 
pois a inspeção da condição só é feita após a execução do bloco ou ação primitiva. 
 É importante também ressaltar que não há necessidade dos delimitadores de 
bloco (Início - Fim), ao contrário do enquanto, pois o corpo do laço já está delimitado 
pelas palavras “Repita” e “Até”, evitando assim qualquer ambiguidade quanto à 
determinação das instruções a serem repetidas. 
 Da mesma forma que a estrutura enquanto, a estrutura repita também serve para 
construir laços determinados e indeterminados. Serão utilizados os mesmos exemplos 
para comparar as duas estruturas. 
 
Exemplo1: 
Algoritmo soma100_2; 
var 
 numero, soma: inteiro; 
inicio 
 soma←0; 
numero ← 1; 
 Repita 
 soma ← soma + numero; 
 numero ← numero + 1; 
 Até (numero > 100); 
 escrever(“Soma =”, soma); 
Fim. 
 
Exemplo2: 
Algoritmo maior_elemento_2; 
var 
 valor, maior: real; 
Início 
 escreva(“Entre com o valor =”); 
 leia(valor); 
 maior ← valor; 
Lógica de Programação – Prof. Edgar Gurgel 
Página 42 de 63 
 Repita 
 Se valor > maior 
 Então 
 maior ← valor; 
 escreva(“Entre com o valor =”); 
 leia(valor); 
 Até (valor = 0); 
 escreva(“Maior valor =’, maior); 
fim. 
 
 Comparando este algoritmo com o do primeiro exemplo da estrutura enquanto, 
nota-se que a utilização de uma estrutura repita no lugar de uma estrutura enquanto 
corresponde a utilizar como <condição> para o repita a negação da <condição> do 
enquanto. 
 
4 - Para (Repetição com Variável de Controle) 
 Nas estruturas de repetição vistas até agora, ocorrem casos em que se torna 
difícil determinar quantas vezes o bloco será executado. Sabe-se que ele será executado 
enquanto uma condição for satisfeita (Enquanto) ou até que uma condição seja satisfeita 
(Repita). A estrutura Pararepete a execução do bloco um número fixo de vezes, pois 
ela possui limites fixos. O número de repetições do bloco será dado por: 
 
Onde: 
 Vi: valor inicial 
 Vf: valor final 
 Na estrutura Para, usar-se-á o conceito de variável de controle, que será uma 
variável (V) que será incrementada após a repetição de um bloco, de acordo com o valor 
deste incremento (p). 
Sintaxe da estrutura: 
Para v ← vi até vf faça 
inicio 
 instrução 1; 
 instrução 2; 
N = Vf - Vi + 1 
Lógica de Programação – Prof. Edgar Gurgel 
Página 43 de 63 
instrução 3; 
 . 
 . 
 . 
instrução n; 
fim; {fim do para} 
 
 A estrutura Para só aceita repetições determinadas e nestes casos será a mais 
conveniente. Será utilizado o exemplo da soma dos 100 primeiros números inteiros e 
positivos e percebe-se que esta estrutura é mais conveniente porque não é necessário: 
• Inicializar o primeiro inteiro a ser adicionado; 
• Incrementar o valor do inteiro a ser adicionado ao valor da soma; 
• Testar se o valor do inteiro já atingiu o limite. 
 
Exemplo: 
Algoritmo soma100_3; 
var 
 numero,soma: inteiro; 
inicio 
 soma ← 0; 
 Para numero ← 1 até 100 faça 
 soma ← soma + numero; 
 escreva(“Soma =”, soma); 
fim. 
 
Exercícios: 
• Diga o que será escrito nos trechos dos algoritmos abaixo, considere que 
todas as variáveis utilizadas são do tipo inteiro. 
 
34) valor ← 5; 
 Para i ← 1 até 5 faça 
 valor ← valor + i; 
 escreva(valor); 
Lógica de Programação – Prof. Edgar Gurgel 
Página 44 de 63 
35) valor←3; 
 x ←0; 
 Enquanto x < 5 faça 
 início 
 valor ← valor + 1; 
 x ← x + 1; 
 fim; 
 escreva(valor); 
 
36) Faça um algoritmo para exibir todos os números de 1 a 100. 
37) Faça um algoritmo para exibir todos os números de 100 a 1. 
38) Faça um algoritmo para exibir os 100 primeiros números pares. 
39) Faça um algoritmo para ler 10 números e exibir o quadrado de cada 
número lido. 
40) Faça um algoritmo que leia um número, maior que zero, que será o limite 
superior de um intervalo e exibir todos os números impares menores do que 
esse número. 
41) Faça um algoritmo que exiba a soma dos números pares entre 25 e 199. 
42) Faça um algoritmo que exiba a tabuada de multiplicar do número 3. 
43) Faça um algoritmo para ler vários números positivos e exibir a média dos 
números digitados. Quando um numero negativo for digitado, o programa deve 
encerrar e apresentar a média. 
44) Faça um algoritmo para ler vários números e informar quantos números 
entre 100 e 200 foram digitados. Quando o valor 0(zero) for lido, o algoritmo 
deverá cessar sua execução. 
45) Faça um algoritmo para ler vários números inteiros e apresentar o fatorial 
de cada número. O algoritmo se encerra quando se digita um número menor do 
que 1. 
46) Faça um algoritmo para ler com a idade de várias pessoas e exibir: 
Lógica de Programação – Prof. Edgar Gurgel 
Página 45 de 63 
• O total de pessoas com menos de 21 anos; 
• O total de pessoas com mais de 50 anos. 
 Quando uma idade negativa for digitada, o programa deve encerrar e 
apresentar as informações solicitadas. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 46 de 63 
Anexos 
Anexo A – Programação em C++ 
1 - Introdução 
" Linguagem BCPL foi desenvolvida por Martin Richards; 
" Linguagem B desenvolvida por Ken Thompson; 
" Linguagem C desenvolvida por Dennis Ritchie em um DEC DCP-11, usando o 
sistema operacional Unix; 
" Linguagem C with Classes; 
" Linguagem C++ desenvolvida por Bjarne Stroustrup, em 1979, na Bell 
Laboratories, Nova Jersey; 
" C++, já passou por três revisões; 
" Primeira revisão em 1985 e a segunda em 1990; 
" Terceira revisão foi o processo de padronização da C++, com o comitê ANSI 
(American National Standards Institute) e a ISO (International Standards 
Organization); 
" Criação da STL (Standard Template Library), conjunto de rotinas genéricas que 
podem ser usadas para a manipulação de dados; 
" Inclusão da STL na especificação da linguagem C++; 
" Expandiu o escopo da linguagem C++; 
" Padronização da linguagem C++; 
" Padronizada pela pelo documento ISO/IEC 14882:1998; 
" Trata-se de uma linguagem para programadores; 
" Baseia-se no paradigma da programação orientada a objetos; 
" Preocupação com a portabilidade; 
" Deu origem as linguagens Java e C#...; 
" Todo programa C++ possui uma função main; 
" O C++ possui a sua biblioteca padrão de funções (C++ Standard Library); 
" Comentários documentam o programa e melhoram a sua legibilidade; 
" O C++ faz distinção entre maiúsculas e minúsculas (case sensitive); 
" As sentenças terminam por ponto e vírgula (;); 
" Para recepção ou envio de dados os programas em C++ consideram 3 objetos 
padrões do tipo stream: 
" cin (stream padrão de entrada - normalmente o teclado); 
" cout (stream padrão de saída - normalmente o monitor); 
" cerr (stream padrão de erros - normalmente o monitor); 
Lógica de Programação – Prof. Edgar Gurgel 
Página 47 de 63 
2 - Fases de um Programa em C++ 
 
3 - Estrutura de um Programa 
// O nome deste programa é primeiro.cpp 
#include <iostream> 
using namespace std; 
int main() 
{ 
 cout << "Bem Vindo"; 
 cout << "ao C++\n"; 
 system(“pause”); 
 return 0; 
} 
Lógica de Programação – Prof. Edgar Gurgel 
Página 48 de 63 
4 - Estrutura de uma Função 
/*************************** Cabeçalho p/ Comentários ***************************/ 
tipo nomeFunc(parâmetros) 
{ 
 seqüência de comandos 
 retorna var_tipo 
} 
 
5 - Variáveis 
" Os nomes podem ter qualquer tamanho, porém apenas os 31 primeiros 
caracteres são significativos; 
" Antes de sua utilização as variáveis devem ser declaradas. A forma geral para 
declaração de uma variável é: 
" onde tipo é um dos tipos de variáveis C++ (int, float, double, etc) e 
nome é qualquer nome de variável válido; 
" Ex. int soma /* resultado da adição */ 
" Declaração de variáveis inteiras e reais (ponto-flutuante): 
" Inteiros: int quantidade /* no. de unidades */ 
" Reais: float salario /* salario bruto */ 
 
 
 
6 - Operadores Aritméticos 
 
 
 
 
 
 
 
" Observação sobre a divisão: 
" Na divisão inteira a parte fracionária é truncada (descartada) sem 
arredondamento; 
" Ex. 19/10 = 1; 
" Se o divisor ou o dividendo for um número real será realizada uma 
divisão real ao invés da divisão inteira; 
" Ex. 19/10.0 = 1.9 
 
7 - Operadores Relacionais 
 
 
 
Operação Operador
Adição +
Subtração -
Multiplicação *
Divisão /
Resto %
Operador Precedência
( ) Calculados em primeiro 
lugar da esq. p/ dir.
*, / ou % Calculados em segundo 
lugar da esq. p/ dir.
+ ou - Calculados por último da 
esq. p/ dir.
Tipo Operação Operador
igualdade igual ==
diferente !=
relacionais maior que >
menor que <
maior ou igual >=
menor ou igual <=
Operador Precedência
( ) Calculados em primeiro lugar da esq. p/ dir.
*, / ou % Calculados em segundo lugar da esq. p/ dir.
+ ou - Calculados em terceiro lugar da esq. p/ dir.
<, <=, > ou >= Calculados em quarto lugar da esq. p/ dir.
== ou != Calculados em quinto lugar da esq. p/ dir.
= Calculados em último lugar da dir p/ esq.
Lógica de Programação – Prof. Edgar Gurgel 
Página 49 de 63 
8 - Entrada e Saída de dados 
" A E/S em C++ ocorre em streams (fluxo de bytes). Um stream é um objeto 
onde um programa pode inserir ou extrair caracteres; 
" A biblioteca padrão C++ inclui o arquivo de cabeçalho iostream, onde os 
objetos stream de E/S padrão estão definidos; 
" Saídapadrão 
" Normalmente a saída padrão de um programa é a tela do monitor. Em 
C++, o objeto stream para acessá-la é o cout; 
" Para inserir dados no objeto stream cout utiliza-se o operador de 
inserção (<<); 
 
 
 
 
 
• endl (end line) é um manipulador de stream e tem a mesma função de 
\n. Força a exibição de quaisquer dados acumulados até aquele 
momento; 
• std é um ambiente de nomes (namespace). O conteúdo do arquivo de 
cabeçalho iostream faz parte do namespace std; 
• O símbolo (::) chama-se operador binário de escopo; 
• Os exemplos 2 e 3 não mencionam o namespace. Para tanto, é preciso 
utilizar a diretiva using namespace std no início do programa; 
• Os caracteres \n formam uma seqüência de escape e faz com que o 
cursor seja movido para a próxima linha da tela (nova linha). 
• Outras seqüências: 
 
 
 
 
 
" Entrada padrão 
" Normalmente o dispositivo padrão de entrada é o teclado. Em C++, o 
objeto stream associado ao teclado é o cin; 
Exemplos de Uso de cout
 1) std::cout << "Primeiro programa";
 2) cout << "Primeiro programa\n";
 3) cout << Primeiro programa" << endl;
 4) std::cout << "A soma é" << sum << std::endl;
 5) std::cout << "A soma é << a+b << std::endl;
Seqüência Descrição
\r Posiciona o cursor no início da linha atual. Não avança para a próxima linha.
\t Tabulação horizontal. Move o cursor p/ próx. Tabulação. 
\" Imprime as aspas.
\\ Imprime o caracter \ (barra invertida)
Lógica de Programação – Prof. Edgar Gurgel 
Página 50 de 63 
" Para extrair dados no objeto stream cin utiliza-se o operador de 
extração (>>); 
 
 
 
 
" cin só processará a entrada quando a tecla ENTER for pressionada; 
" O tipo do dado digitado deve ser compatível com o tipo definido para a 
variável. Por exemplo, se a variável é inteira somente inteiros devem 
ser digitados; 
" O exemplo 3 é equivalente aos exemplos 1 e 2. Em ambos os casos 
devem ser digitados um valor para a variável a e outro para a variável 
b, separados por espaço, tab ou uma nova linha; 
" cin pode ser utilizado para a leitura de strings. Entretanto, a extração de 
cin termina assim que um espaço em branco for encontrado, fazendo 
com que apenas uma palavra seja extraída. Sendo assim, para a leitura 
de uma linha inteira pode ser utilizada, por exemplo, a função getline; 
 
9 - Tipos de Dados 
" char 
" Um único byte, capaz de conter um único caractere; 
" int 
" Um inteiro, normalmente reflete o tamanho natural dos inteiros da máquina 
host; 
" float 
" Ponto flutuante em precisão simples; 
" double 
" Ponto flutuante em precisão dupla; 
" qualificadores 
" short, long; 
" signed, unsigned. 
 
 
Exemplos de Uso de cin
 1) std::cin >> a;
 2) cin >> b;
 3) cin >> a >> b;
Lógica de Programação – Prof. Edgar Gurgel 
Página 51 de 63 
10 - Estruturas 
 
10.1 - Estrutura de Seleção 
/* Utilizando a estrutura o comando if... else... 
 Este é o segundo programa e o seu nome é segundo.cpp */ 
#include <iostream> 
using namespace std; 
 
int main() 
{ 
 double grau = 5.0; 
 if(grau >= 7.0) 
 cout << "Aprovado\n"; 
 else 
 { 
 cout << "Reprovado\n"; 
 cout << "por nota\n"; 
 } 
 system(“pause”); 
 return 0; 
} 
 
10.2 - Estrutura de Seleção Encadeada 
if(grau >= 90) 
 cout << “A\n”; 
else 
 if(grau >= 80) 
 cout << “B\n”; 
 else 
 if(grau >= 70) 
 cout << “C\n”; 
 else 
 if(grau >= 60) 
 cout << “D\n”; 
 else 
 cout << “F\n”; 
Lógica de Programação – Prof. Edgar Gurgel 
Página 52 de 63 
10.3 - Estrutura de Repetição While 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
10.4 - Estrutura de Repetição For 
Sintaxe: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
produto = 2; 
while(produto<=1000) 
 produto = 2 * produto; 
while(contador <= 10) 
{ 
 cout << “Digite o grau:\n”; 
 cin >> grau; 
 total=total + grau; 
 contador=contador+1; 
} 
for (expr1;expr2;expr3) 
 comando; 
for(i=1;i<=100;i++) 
 
for(i=100;i>=1;i--) 
 
for(i=7;i<=77;i+=7) 
 
for(i=20;i<=2;i-=2) 
 
for(;;) 
Lógica de Programação – Prof. Edgar Gurgel 
Página 53 de 63 
Anexo B – Tutorial Dev C++ 
 
Baixe o Dev C++ em http://www.bloodshed.net/index.html 
 
1. Abrindo o Programa 
Depois de instalar o Dev C++, abra o programa. Selecione a língua <Português 
(Brazil)> e clique em <Next> 
 
 
Clique no botão <Next> 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 54 de 63 
Clique no botão <Next> 
 
	
  
Clique no botão <OK> para concluir a configuração 
 
 
 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 55 de 63 
2. Criando um Projeto 
Entre em Arquivo # Novo # Projeto 
 
 
Aparecerá a tela abaixo: 
 
 
Escolha o tipo de projeto que você pretente iniciar e nomeie seu projeto. 
 
	
  
Lógica de Programação – Prof. Edgar Gurgel 
Página 56 de 63 
Escolha se seu projeto será em C ou C++. 
 
	
  
Após isso clique em <OK>. Aparecerá uma tela para escolher o local para 
salvar o seu projeto. 
 
	
  
Feito isso clique em <Salvar>. 
Agora iremos criar um novo arquivo fonte para dar início a construção de nosso 
programa. 
 
 
 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 57 de 63 
Vá em Arquivo # Novo # Arquivo Fonte (ou use o atalho no teclado 
<Ctrl+N>). 
 
	
  
Agora você está pronto para iniciar seu programa. 
 
3. Compilando um Programa 
Quando seu programa estiver finalizado vá em Menu # Executar # Compilar 
ou <Ctrl+F9> 
 
	
  
	
  
	
  
Lógica de Programação – Prof. Edgar Gurgel 
Página 58 de 63 
Aparecerá a tela abaixo: 
 
	
  
Isto significa que seu programa não contém erros e pode ser executado. 
Vá em Menu # Executar # Executar ou <Ctrl+F10>. Salve junto ao seu 
projeto. 
 
	
  
 
Seu programa será executado. 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 59 de 63 
4. Abrindo Programas Existentes 
Vá em Menu # Arquivo # Abrir projeto ou arquivo Ctrl+O 
 
	
  
	
  
Encontre a origem do projeto ou aquivo. 
 
	
  
Clique em <OK>. 
 
 
 
 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 60 de 63 
Anexo C – Tutorial Visual Studio C 
• Interface New project 
• Escolher Win32 
• Marcar Win32 console application 
• Colocar o nome do projeto <Enter_name> 
• Não é necessário procurar diretório, somente se você quiser mudar o padrão 
• Desmarcar a caixa Create directory solution 
• Clicar em Ok 
 
 
• Interface Win32 Application Wizard 
• Marcar console application 
• Marcar empty project 
• Clicar em Finish 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 61 de 63 
• Interface Gráfica do Visual Studio 
• Botão direito em Source Files 
• Add 
• New Item... 
 
 
 
 
• Interface Add New Item: 
• Clicar em Code 
• Colocar nome e clicar em C++ File (.cpp) 
• Clicar no botão add 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 62 de 63 
 
• Interface Gráfica do Visual Studio 
• Marcar na barra de ferramentas debug ou release 
 
 
• Interface Gráfica do Visual Studio (Compilando) 
• Clicar na barra de menu Build 
• Build Solution ou F7 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Lógica de Programação – Prof. Edgar Gurgel 
Página 63 de 63 
• Interface Gráfica do Visual Studio (Executando) 
• Clicar na barra de menu Debug 
• Start debugging ou F5 
 
 
 
 
 
• Em seguida aparecerá uma janela de console (janela preta)

Outros materiais