Anotações de aulas de Algoritmos

Prévia do material em texto

AL notas de aula.txt
ALG - A1 _________________________________________________________________
LV: FEOFILOFF, P. Algoritmos em linguagem C. Rio de Janeiro: Campus, 2008.
FORBELLONE, A. L. V.; EBERSPACHER, H. F. Lógica de programação: a construção de 
algoritmos e estruturas de dados. São Paulo: Makron Books, 1993.
MANZANO, J. A. N. G.; OLIVEIRA, J. F. D. Algoritmos: lógica para desenvolvimento
de programação. 9. ed. São Paulo: Érica, 1996.
NA: Lógica > Trata-se da Ciência que estuda as formas do pensamento
A forma de representar o pensamento é muito importante na programação de 
computadores > programador pensa em um programa - precisa saber expressar seu 
raciocínio por meio de uma representação ou mesmo de uma linguagem gráfica
Na informática usamos alguns recursos para representar o conhecimento > mais 
comuns são os fluxogramas e os algoritmos 
Fluxograma > uma representação gráfica de um processo ou fluxo de trabalho - com
figuras geométricas padronizadas e setas ligando as figuras
O fluxograma utiliza diagramas para representar e facilitar o entendimento de um
algoritmo
O algoritmo > um conjunto de regras para chegar a resultados, sejam eles 
conclusivos ou que podem fazer com que retorne (ou pule) para determinada parte 
da regra > o fluxograma tem como finalidade mostrar graficamente através de 
símbolos pré-definidos como o algoritmo funciona
Algoritmo > a representação do pensamento descrito como uma sequência de passos 
que visam atingir um objetivo
Algoritmos > são independentes da linguagem de programação
Importância dos algoritmos na programação > servem para representar o raciocínio
de uma resolução algorítmica do problema
A forma mais comum de escrever um algoritmo é usar uma linguagem chamada de 
português estruturado ou portugol
Português estruturado (pseudocódigo) > uma simplificação da nossa linguagem 
natural, na qual usamos frases simples e estruturas que possuem um significado 
muito bem definido
A linguagem de programação é a maneira utilizada de formalizar a solução de um 
problema do mundo real a partir dos algoritmos
O algoritmo pode ser representado de três maneiras: 
Linguagem gráfica > Sua simbologia é amplamente conhecida, por isto sua 
aplicação não se restringe apenas a algoritmos computacionais (fluxogramas)
Pseudocódigos > Sua simbologia e sintaxe aproxima-se muito a simbologia e a 
sintaxe da maioria das linguagens de programação.
Linguagem natural > A grande ambiguidade existente nos significados de seus 
termos é uma restrição a representação aos algoritmos computacionais
Hardware > história do computador em gerações > 1ª ger. 1943 ENIAC (válvulas) / 
2ª ger. 1947 (transístor) e primeiras linguagens de programação / 3ª ger. 
1965-1970 (circuito integrado ou microchip) / 4ª ger. 1970 (microprocessador) / 
depois uma evolução muito rápida (Porém a "arquitetura interna" de organização e
de relacionamento entre os componentes eletrônicos não se modificou muito - as 
variações obedecem aos princípios da arquitetura criada por John Von Neumann)
Página 1
AL notas de aula.txt
Elementos da arquitetura interna por Neumann: memória (primária [RAM] e 
secundária) / unidade de controle ([CU] - sincroniza os demais componentes) / 
unidade lógica e aritmética [ULA] (responsável por cálculos e controles) / ES
** Memória ROM > elemento do computador com informações gravadas sobre as 
rotinas de inicialização feitas pelo fabricante (não pode ter dados gravados 
pelo usuário)
** CPU -> "cérebro do computador" >> seguintes elementos: CU / ULA / 
Registradores
VA: história da programação - escrita cuneiforme (documentando instruções e 
processos do dia-a-dia) / Musa al-Khwarismi com trabalhos algébricos em 
linguagem natural (origem do algoritmo) / Ada Lovelace escreve um algoritmo (um 
programa) para máquina de calcular de Babbage / 1ªs linguagens: plankalkul 
(planilha de cálculo) utilizada no computador (ábaco) mecânico chamado Z1 
(programável com fitas perfurados; números de ponto flutuante; binário; com 
expoentes) / 1950 - programação física - trocar fios de lugar, perfurar cartões 
e testar / 1954 - 1ªs ferramentas: montadores e compiladores primitivos (poupar 
tempo dos programadores) / 1ª linguagem de programação [LP] popular FORTRAN 
(IBM) - criou um compliador (diminui erros e gera código de qualidade) - usada 
até hoje para previsão do tempo e mecânica de fluídos / Backus (IBM) - outras 
LPs Algol, BNF e FP (fuction point - ling. específica) / 1954 - LISP (aplicada 
em inteligência artificial) - influências como a recursão, as expressões 
condicionais, usadas até hoje (coleta de lixo) / 1957 - surge a linguagem 
universal independente de máquina (padronização) - Algol (precursora do Pascal) 
- influência (herança): blocos delimitadores, estrutura léxica de formato livre,
sintaxe definida via BNF, escopo de blocos para variáveis locais, tipagem 
estática, aninhamento de if-then-else, chamada por valor, recursão e expressões 
condicionais, alocação dinâmica de meória, procedimentos de primeira classe, 
operadores definidos pelo usário / LP Smalltalk e Simula - programação orientada
a objetos - usadas até hoje
Evolução das LP usadas na disciplina: Algol 60 > CPL > BCPL > B > C > C++
AT: Quais são as linguagens mais usadas atualmente? TIOBE programming community 
index
TC: 100%
ALG - A2 _________________________________________________________________
NA: Programa > uma sequência de comandos ou ordens dados a um computador
Compilação > quando o arquivo de texto é convertido em uma linguagem que o 
computador entende, para executar o programa
Programa -> código fonte em linguagem de alto nível -> compilador -> programa 
objeto -> linguagem de programação em códigos binários pertencentes a uma 
plataforma de execução
> para começar o programa usa sempre a linha: 
int main(int argc, char** argv) {
> as linhas intermediárias podem receber dados variáveis, p.e:
2 float nota1;
3 float nota2;
Página 2
AL notas de aula.txt
** Float significa flutuar > no caso são notas (nota1, nota2, nota3, nota4...) >
são números de ponto flutuante [decimais]
> saída de dados > inserir na linha 14 o seguinte comando:
14 cout<<”O valor da media eh: “<<media;
**Em C++, o cout é o comando que exibe uma mensagem na tela - faz a saída de 
dados / após o comando cout, temos o operador “<<” / tudo o que vier após o “<<”
será impresso na tela
> para terminar o programas usa-se sempre o comando da linha 15:
 15 return 0;
> a linha 16 também é muito importante, fecha o bloco de programa aberto na 
linha 1:
 16 }.
> Em C++ se você abre uma porta tem que fechar -> se você abre uma chave “{“ tem
que fechá-la “}”
**Notas importantes:
> Em todas as linguagens de programação, alguns comandos precisam de caracteres 
que iniciam outra expressão ou bloco de informações ou comandos: é o caso dos 
caracteres (, [, {, “, ‘e, dependendo da linguagem, outros ainda são 
necessários, como < e >
> Em C++, todas as variáveis inseridas precisam ser declaradas em linhas de 
comando
> Em C++, se você declarar uma variável “nota”, ela será diferente de “Nota”, 
“NOTA”, nOta” etc.
> Inicie os programas com int main (int argc, char** argv) { e termine com 
return 0.
> Use as endentações, linhas brancas e comentários / comentários são delimitados
por /* */ ou ainda //
> As linhas de códigos / instruções são sempre terminadas por ponto-e-vírgula 
(;)
> entrada-processamento-saída > Todo algoritmo ou programa tem um objetivo > é 
alcançado por meio de uma ENTRADA de dados, a qual será PROCESSADA e resultará 
em uma SAÍDA que será avaliada > Se a entrada for ruim, é problema, pois serão 
os dados ainda processados da maneira correta, no entanto, a saída será ruim
* fazer a correta entrada de dados é fundamental
**Variável > necessita de espaço na memória e define o tipo de dado a ser 
armazenado> diretivas de pré-processamento > ficam as bibliotecas e funções pré-definidas 
e prontas que podem ser usadas
> declarações globais > criamos as variáveis globais, constantes e estruturas 
que serão usadas e visíveis por todas as partes do programa
Página 3
AL notas de aula.txt
> declarações de funções > funções que serão utilizadas pelo programa
> programa principal [main] > o programa todo fica dentro do bloco que começa 
com { e termina com }
> definições locais > variáveis locais do programa
> instruções > os comandos e instruções do programa -> onde a parte principal 
fica armazenada
> finalização > observe o } para finalizar o bloco de programação
VA: O mais importante na programação é entender como montar os programas
> o programa é montado em linguagem de alto nível
> o editor de texto mais simples da plataforma é suficiente para escrever um 
programa
> depois esse programa deve ser compilado [em um programa compilador] para 
executá-lo
> pelo compilador se cria o programa objeto
> em outro programa Linker os códigos do programa objeto são convertidos em 
código de máquina [binária]
> dicionário de palavras reservadas de C++ é maior que o dicionário de C
> estrutura geral do C++:
 int main(int argc, char** argv) {
 definições locais -> variáveis
 instruções
 return 0;
 }
** em outros programas encontram-se mais sequências de comando, além dos cinco 
de C++:
diretivas de pré-processamento / declarações globais / declarações de funções
AT: instalar o Dev C++
TC: 75%
ALG - A3 _________________________________________________________________
NA: para programar > é possível executar o compilador na linha de comando pelo 
editor de texto e acompanhar os resultados gerados > OU utilizar softwares 
conhecidos como IDE (integrated development environment ou ambiente de 
desenvolvimento integrado), que facilitam o trabalho
> IDE >> têm a função de colocar e integrar, em um mesmo ambiente, vários outros
programas que ajudam um programador a criar seus programas
> A IDE integra o complidador e o linker no mesmo ambiente > por ele o programa 
é compilado, verificado e depois linkado, gerando o executável
> IDE -> é um conjunto de programas úteis ao programador reunidos em um mesmo 
ambiente, a fim de facilitar o trabalho de desenvolvimento
> a linguagem C++ possui vários IDEs diferentes > DevC++ foi escolhido
> baixar o DevC++ > o nome do arquivo contém 'TDM-GCC' > o que significa que a 
versão baixada vem com o compilador GCC, que é específico para o C++
** Refatoração
 > Melhorar o código por meio da construção de um código mais eficiente, sem 
abalar a estrutura geral do programa e geralmente contando com a colaboração de 
outros membros da equipe
Página 4
AL notas de aula.txt
> DevC++ trabalha com um tipo de arquivo chamado de projeto
> Um projeto é um agregador de recursos >> quando desenvolvemos um software, 
além dos arquivos de código-fonte, podemos ter imagens, bibliotecas de terceiros
que podemos incluir no nosso programa, arquivos de configuração e outros
> DevC++ > altera cor do código de acordo com o tipo de comando ou instrução que
está sendo trabalhado -> as strings ficam em azul, as palavras-chave ficam em 
negrito, as diretivas ficam em verde e assim por diante
** String
 > é uma sequência de caracteres > p.e.: ‘O’ ‘l’ ’á’ [são caracteres] - quando 
os juntamos para formar uma frase como “Olá” temos uma string >> É sempre 
representada entre aspas
** Tabela de caracteres ASCII -> American Standard Code for Information 
Interchange
** REGRAS PARA NOMEAR VARIÁVEIS
> Letras maiúsculas e minúsculas do alfabeto Inglês (diferenciando maiúsculas de
minúsculas - Case sensitive), dígitos de 0 a 9 e o caracter underscore "_" 
poderão ser usados.
> O primeiro caracter NÃO pode ser dígito.
> Nenhuma palavra reservada deverá ser usada para nome de variável.
>> Sugestões
> Embora o caractere underscore possa ser o primeiro, não é aconselhável. 
Procure usá-lo nos nomes compostos.
> Você também pode adotar a “convenção” de usar letra maiúscula para a primeira 
letra de cada palavra, a partir da segunda, e não usar underscore. Exemplo: 
notaDaProva
> Procure dar nomes significativos, evitando muitos comentários no código.
** Comentários poderão ser feitos em seu código para esclarecimentos ou 
identificações de trechos
Será possível comentários de uma linha: // ou um bloco de linhas: /* */
 // Nomes válidos: nome, Nota, p1, p2, mediaDaTurma, media_da_turma
 /* Nomes inválidos: preço, 2p, media aluno, n#2 */
> fazer o programa da AULA 2 [medias] - ok
> Compilar >> em um programa novo é obrigatório e inicial > Sem ela, a execução 
não é possível > muitas vezes, durante o desenvolvimento do programa, é 
necessário somente compilar o programa sem precisar necessariamente executá-lo
> Executar >> executa o programa previamente compilado > Em programas pequenos, 
a etapa de compilação é muito rápida / Já em programas grandes, a compilação 
pode levar vários minutos > Quando a compilação já foi executada com sucesso é 
possível usar a opção para somente executar
> fazer o programa da AULA 2 [temperaturas] - ok
> cout >> é o responsável por exibir algo na tela
Página 5
AL notas de aula.txt
> O cout consegue mesclar valores armazenados em variáveis [valores] e frases 
[strings] -> Esta mistura em computação é chamada >> concatenação* > p.e.:
cout<<celsius<<" graus Celsius equivale a "<<fahrenheit<<" graus Fahrenheit.";
*a operação de unir o conteúdo de duas strings
> depuração >> é uma atividade que permite ao programador executar o programa 
passo a passo > ele pode verificar os valores das variáveis e descobrir qual é a
execução natural de um programa
> Em um programa sequencial a depuração é tranquila / em programas que possuem 
desvios condicionais e repetições, o depurador realmente fará diferença durante 
o seu desenvolvimento
> Breakpoint > é um ponto de parada >> após o compilador ter feito a sua parte, 
o depurador entrará em execução e rodará o programa até a linha que tem o 
breakpoint > esta linha (breakpoint) estará marcada em vermelho
> para criar um breakpoint >> podemos usar o mouse clicando na linha desejada >>
ou usar o menu Executar >> ou ainda usar a tecla F4
> durante a depuração, a tela do DevC++ muda para o modo Depurador > aparecem 
alguns botões diferentes
**Depuração é um debug -> tirar os erros do programa / depurador = debugger
> recursos do C++:
>> As propriedades do projeto: menu Arquivo-Propriedades
 -> ver a quantidade de linhas do arquivo, quantas linhas estão vazias, linhas 
de código etc. [importante para o tamanho do software, p.e.]
>> Configuração do ambiente
 -> tela podem ser configuradas várias opções como por exemplo criar arquivos de
backup automaticamente, mudar o tema (aparência) do DevC++, entre outras
>> Opções do Editor
 -> configura o comportamento do DevC++ em várias situações, como por exemplo, a
autoendentação, posições do cursor etc.
**refatoração > permite melhorar o código
VA: IDE (Integrated development enviroment) > características e ferramentas mais
comuns:
> editor
> compilador (compiler)
> linker
> depurador (debugger)
> modelagem (modeling)
> geração de código
> testes automatizados
> refatoração (refactoring)
No C++ todos os comentários são apresentados nessa forma: /* ... */
/* qualquer texto escrito entre barras e asteriscos não aparece e nem interfere 
no programa */
>> todo arquivo em C++ tem a extensão .cpp
>> Palavras reservadas são todas em negrito (ver as palavras reservadas de C++)
>> Todo delimitador são em vermelho [chaves, parênteses...]
Página 6
AL notas de aula.txt
>> hashtag em verde é diretiva de pré-processamento
>> comandos presentes em bibliotecas externas -> inserir diretiva para importar 
a biblioteca > p.e. iostream [in out stream] = fluxo de entrada e saída
1 #include<iostream>
2 using namespace std;
>> para mostrar informações na tela utiliza-se o comando cout (saída)
>> para inserir dados no programa executável utiliza-se o comando cin (entrada)
P.e. > comando de entrada e saída em C++:
cout << "lendo a idade"; cin >> idade;
>> recurso using namespace std -> espaço de nomes padrão [std - standard] -> é 
uma regra:
> se for usar cin e cout, obrigatoriamente tem que importar o iostream e 
utilizar a diretiva de using namestream std
> Depuração > é um tipo de demarcação > uma atividade que permite ao programador
executar o programa passo a passo > para verificar os valores da variáveis e 
descobrir qual é a execução natural de um programa
>> o programa que possibilita acompanhar a execução do programa e verificar 
erros
> endl -> endline - pula para outra linha
AT: realizar programas - ok
>> Se quando tentarmos compilar um programa surgir uma mensagem de erro, 
sinalizando que cout não foi declarado, qual a primeira providência? observar se
escrevemos corretamente iostream
TC: 83%
ALG - A4 _________________________________________________________________
LV: ver o capítulo 2 do livro didático 
NA: os tipos primitivos > p.e. no campo "gênero" de um formulário os possíveis 
valores que ele pode assumir serão masculino ou feminino >> no banco de dados do
sistema ele ficará armazenado como “m” ou “f” >> 
Ou seja, na definição desse formulário, haverá uma variável chamada gênero, a 
qual poderá guardar apenas dois valores: “m” ou “f”
> Tipos de dados:
 int - armazena uma número inteiro no intervalo: -2147483648 até 2147483647;
 char - armazena um caractere;
 float - armazena um número real com pouca precisão; 
 double - armazena um número real com precisão maior do que o tipo float;
 void - tipo vazio / informa ao compilador que a variável não terá um tipo 
definido;
 bool - armazenará somente um dos valores: false ou true / 0 ou qualquer;
 
> Variações dos tipos de dados, que usam os seguintes modificadores de tipos:
 unsigned char: caractere sem sinal;
Página 7
AL notas de aula.txt
 long int: número inteiro, com domínio estendido - armazena um inteiro bem 
grande;
 unsigned int: número inteiro positivo;
 unsigned long int: número inteiro positivo com domínio estendido;
 short int: inteiro com domínio reduzido;
 unsigned short int: inteiro positivo com domínio reduzido
** ver tabela de tipos de dados
> Em C++, é obrigatório que toda variável usada no programa seja declarada
>> A declaração reserva o espaço em memória necessário para a alocação do 
conteúdo que receberá
>> A sintaxe da declaração de variáveis em C++ é:
 tipo_da_variável 
lista_de_variáveis_separadas_por_vírgulas;
* é preciso que o seu tipo venha em primeiro lugar e depois a variável desejada 
/ ou uma lista de variáveis, separada por vírgula 
> regras para a escolha dos nomes de variáveis em C++:
 Nomes de variáveis só podem conter letras, números e o caractere “_”;
 Não podem começar com um número; 
 Embora seja possível ter uma variável com o nome “_var” (começando com “_”), 
estes são reservados para a implementação interna do programa, e seu uso é bem 
restrito e desaconselhado;
 Não é possível utilizar palavras reservadas da linguagem C++ [ver lista];
 Também não é possível criar uma variável que tenha o mesmo nome de uma função,
mesmo que essa função tenha sido criada pelo programador ou que seja uma função 
de biblioteca;
 Não há limite para o tamanho de nome de variável em C++;
 Quando criarmos constantes, estas devem ser escritas com todas as letras em 
maiúsculas
> p.e. declarações de variáveis:
 int a;
 char a, b, c;
 unsigned int x1, x2, media;
 char _a;
**São cinco tipos nativos em C++: int, float, double, char e bool
> lista de palavras reservadas: auto / double / int / struct / break / else / 
long / switch / case / enum / register / typedef / char / extern / return / 
union / const / float / short / unsigned / continue / for / signed / void / 
default / goto / sizeof / volatile / do / if / static / while
> para saída de dados [exibir mensagem na tela - cout] é necessário inserir duas
linhas no início do programa:
1 #include <iostream>
2 using namespace std;
>> a primeira inclui na compilação do programa a biblioteca iostream -> esta bb 
contém várias funções prontas como o cout e cin
>> a segunda linha é necessária pois define um espaço de nomes chamado std -> a 
Página 8
AL notas de aula.txt
ausência dessa linha demanda a indentificação do espaço em toda a programação: 
3 std::cout<<"exemplo de saida"<<std<<endl;
> Operadores aritméticos em C++:
+ | soma (inteira e ponto flutuante)
- | subtração ou troca de sinal (inteira e ponto flutuante)
* | multiplicação (inteira e ponto flutuante)
/ | divisão (inteira e ponto flutuante)
% | resto de divisão (inteiros)
>> exemplo do uso do resto da divisão: 10|2_
 0 5 resto é 0 -> a representação 10 %
2 = 0
 9|2_
 1 4 resto é 1 -> a representação 9 % 
2 = 1
>> também é possível realizar operações um pouco mais complexas -> cálculo de 
senos, cossenos, raiz quadrada
>> bibliotecas para as funções matemáticas > p.e. a "cmath"
** Como eu vou saber qual biblioteca preciso? -> estude a API da linguagem 
[Application Programming Interface ou Interface de Programação de Aplicativos]! 
>> ver site <http://www.cplusplus.com/reference/>
> Operadores lógicos -> situações de comparação entre valores, e essa comparação
faz parte de um tipo de operação chamada de operação lógica >> faz parte de uma 
lógica chamada proposicional e foi muito estudada por um matemático chamado 
George Boole [álgebra booleana] -> trabalha principalmente com valores booleanos
ou lógicos, e basicamente nesta lógica só existem dois valores: verdadeiro 
(true) ou falso (false)
** Tudo que conhecemos na computação atual é baseada nessa álgebra
>> Na aritmética binária, de certa forma, também estamos trabalhando com a 
álgebra de Boole, e neste caso normalmente usamos 0 para valores falsos e 1 para
verdadeiros
> álgebra booleana tem basicamente três operadores:
O operador lógico “E”, em C++: &&
O operador lógico “OU”, em C++: ||
O operador de negação, em C++: !
** o operador ! nega (inverte) o resultado -> p.e. se A=3 e B=7 confirmar: 
!(A>B) resultado: !(3>7) -> !(falso) -> verdadeiro
tabela verdade -> mostrar os valores possíveis que as variáveis lógicas podem 
assumir -> todas as possibilidades combinatórias entre os valores de diversas 
variáveis lógicas que são encontradas em somente duas situações e um conjunto de
operadores lógicos >> p.e. A e B são proposições:
 A | B | A && B | | A | B | A || B | 
 V | V | V | | V | V | V | 
Página 9
AL notas de aula.txt
 V | F | F | | V | F | V | 
 F | V | F | | F | V | V | 
 F | F | F | | F | F | F | 
** Em uma expressão envolvendo o operador E (&&), a expressão só será verdadeira
se todas as partes da expressão forem verdadeiras. Se contiver uma só que seja 
falsa, toda a expressão será falsa;
 Em uma expressão envolvendo o operador OU (||), a expressão só será falsa se 
todas as partes da expressão forem falsas. Se contiver uma só que seja 
verdadeira, toda a expressão será verdadeira
> Os operadores relacionais são usados para fazer comparações entre dois 
operandos do mesmo tipo primitivo > Esses valores são representados por 
constantes, variáveis ou expressões aritméticas
operador | descrição
 == | igual
 > | maior que
 < | menor que
 != |diferente
 >= | maior ou igual que
 <= | menor ou igual que
> bool é um tipo em C++ e pode assumir os valores booleanos true ou false;
** TIPO DE DADOS LÓGICO >> O tipo de dados primitivo mais simples é o chamado 
booleano ( ou lógico ) >> dado booleano só pode assumir dois valores ( 
VERDADEIRO ou FALSO )
OS OPERADORES LÓGICOS >> As operações lógicas trabalham sobre valores booleanos,
tanto os valores de entrada como o de saída são desse tipo >> Os operadores 
lógicos são: E, OU, NÃO, NÃO-E, NÃO-OU, OU-EXCLUSIVO E NÃO-OU-EXCLUSIVO
-> Operador “E” ou “AND” resulta em um valor VERDADEIRO se os dois valores de 
entrada da operação forem VERDADEIROS, caso contrário o resultado é FALSO
-> Operador “OU” ou “OR” resulta em um valor VERDADEIRO se ao menos UM dos dois 
valores de entrada da operação for VERDADEIRO, caso contrário o resultado é 
FALSO
-> Operador “NÃO” ou “NOT” é o único operador que recebe como entrada apenas um 
valor, e sua função é simplesmente inverter os valores. Ou seja, se o valor de 
entrada for VERDADEIRO, o resultado será FALSO e se o valor de entrada for 
FALSO, o resultado será VERDADEIRO
-> Operador “NÃO-E” ou “NAND” é o contrário do operador E (AND), ou seja, 
resulta em VERDADEIRO, se ao menos um dos dois valores for FALSO, na verdade 
este é o operador E (AND) seguido do operador NÃO (NOT)
-> Operador “NÃO-OU” ou “NOR” é o contrário do operador OU (OR), ou seja, 
resulta em VERDADEIRO, se os dois valores forem FALSO, na verdade este é o 
operador OU (OR) seguido do operador NÃO (NOT)
Página 10
AL notas de aula.txt
-> Operador “OU-EXCLUSIVO” ou “XOR” é uma variação interessante do operador OU 
(OR), ele resulta em VERDADEIRO se apenas um dos valores de entrada for 
VERDADEIRO, ou seja, apenas se os valores de entrada forem DIFERENTES
-> Operador “NÃO-OU-EXCLUSIVO” ou “XNOR” é o contrário do operador OU-EXCLUSIVO 
(XOR), ou seja, resulta VERDADEIRO se os valores de entrada forem IGUAIS
->> utilizamos esses operadores praticamente o tempo todo, principalmente para 
controle de fluxo de execução e tomadas de decisão
VA: tipos primitivos >> tipos básicos de variáveis: char (guarda um caractere) /
int (guarda um número inteiro) / float (guarda um número real com certa 
precisão) /double (guarda um número real, mais preciso que o float) / void (tipo
vazio - informa ao compilador que a variável não terá um tipo definido)
>> tipo modificados: unsigned char / unsigned int / long int / unsigned long int
/ short int / unsigned short int
** em C++ é obrigatório que toda variável seja declarada antes de ser utilizada
> a sintaxe da declaração de variáveis é: tipo da variável [char, int, outra] e 
a lista de variáveis [char -> a, b, c / int -> idade, meses, x1, media]
>> p.e string nome -> variável chamada 'nome' do tipo 'string'
** quanto mais souber de biblioteca, mais produtiva a programação
** existem bibliotecas para tudo em C++ (tudo mesmo!)
AT: realizar o programa do nome >> usar a biblioteca string ou cstdlib >> ok
**para pular linha no programa utiliza:
 cout<<"\n";
1. Considere a = 1 b = 2. Usando os operadores que vimos nesta aula, 
observe:
a) a > b a é maior que b? ( ) Sim / (x) Não
b) b >= a b é maior ou igual a a? (x) Sim / ( ) Não
c) a == b o valor de a é igual ao valor de b? ( ) Sim / (x) Não
2. Nas situações abaixo, assinale V ou F para avaliar as sentenças.
Seja: A=3 B=7 Total=200.0 Média=8.1 Ano=2000
a) ( ) A > B
b) ( ) Total == 100.0
c) ( ) Média >= 7
d) ( ) Ano != 2001
e) ( ) !(A>B)
f) ( ) (A<B) && ((Total+1) >= 200.0)
g) ( ) (Ano+15) == 2015
h) ( ) !((A+B) > (B-A))
i) ( ) (A>B) || (Média>=6)
j) ( ) ((A+B)!=10) || (Ano+15>2015)
Gabarito 1. a) N b) S c) N
 2. a) F b) F c) V d) V e) V f) V g) V h) F i) V j) F
Página 11
AL notas de aula.txt
SLIDES aula_intr_1 parei no 50
TC: 100%
ALG - A5 _________________________________________________________________
NA: Elementos de programação estudados: 
 Bloco de programação;
 Entrada e saída de dados; 
 Variáveis;
 Constantes;
 Atribuições; 
 Expressões lógicas; 
 Expressões relacionais; 
 Expressões aritméticas; 
 Comandos sequenciais
> Em programas de computador, as decisões são comuns: quando você abre um 
arquivo, SE ele for protegido, ENTÃO vai aparecer uma janela avisando
>> a condição lógica é importante! Estas condições têm que ser muito bem 
montadas para poder executar o programa corretamente
>> Desvio de condicional simples e composto, p.e:
8 numero1 = */ **entrada*** ***enter** /*
9 numero2 = */ **entrada*** ***enter** /*
10
11 if ( numero1 > numero2 ) { */ condicional simples /*
12 cout<<"condição verdadeira"; */ condicional simples /*
13 } */ condicional simples /*
14 else { */ condicional composto /*
15 cout<<"condição falsa"; */ condicional composto /*
16 } */ condicional composto /*
17 cout>> "fim do programa"
>> cálculo do IMC (índice de massa corporal), p.e.:
a fórmula é -> IMC = __Peso_(em_kg)__
 altura (em m)²
traduzindo para linguagem de C++ -> IMC = peso/(altura*altura) OU 
IMC=peso/(pow(altura,2))
* pow (base, expoente) é uma função da biblioteca cmtah que podemos usar para 
fazer cálculos com potenciação
> A sintaxe de um IF em C++:
 if (teste/condição) {
 bloco de comando quando o teste/condição for true
 } 
** os parênteses são obrigatórios para a condição de teste
 a estrutura sempre começa com a palavra chave IF
 após a condição, deve-se abrir um bloco de comando que começa com { e termina
com }
 O uso das chaves é obrigatório quando for usada mais de uma instrução dentro 
Página 12
AL notas de aula.txt
da estrutura de decisão - if - usar sempre não ocasionará problemas
> Nesse teste é possível utilizar qualquer tipo de expressão que possa ser 
avaliada e retornar verdadeiro (true) ou falso (false) >> Se o teste for 
verdadeiro, o bloco é executado / Se for falso, o bloco é ignorado completamente
e o fluxo do programa continua na linha seguinte ao bloco >> O tamanho do bloco 
pode ser de 1, 2, 200, 2.000 linhas. De qualquer forma, se o teste for false, 
todo o bloco, independentemente do tamanho que seja, será ignorado
> Desvio condicional composto >> Em C++, a sintaxe é a seguinte:
 if (teste/condição) {
 bloco de comando quando o teste/condição for true
 } 
 else {
 bloco de comando quando o teste/condição for false
 } 
* Temos então uma nova palavra ao nosso vocabulário de C++: else. Esta palavra é
equivalente ao “senão”
VA: estrutura de desvio condicional simples e composto
> IF > operadores relacionais:
 operador | símbolo
 (igual a) | ==
 (diferente de) | !=
 (maior que) | >
 (menor que) | <
 (maior ou igual que) | >=
 (maior ou igual que) | <=
 AND | && ou * [triângulo]
 OR | || ou + [redondo]
 NOT | ! [bolinha na ponta]
 (resto da divisão) | %
> IF [se] ou ELSE [se não] >>
 if (teste/condição){
 bloco de comandos quando teste for true
 }
 else{
 bloco de comandos quando teste for false
 }
AT: Em um programa para se determinar se o número é par ou ímpar, vamos precisar
dos seguintes recursos:
I - Do operador mod (%) / II - De um desvio condicional composto / III - Da 
biblioteca cmath
RESP -> I e II:
int main (void){
 int num;
Página 13
AL notas de aula.txt
 cout<<"\nDigite um numero:";
 cin>>num;
 if (num %2 ==0){
 cout<<"PAR";
 }
 else {
 cout<<"IMPAR";
 }
 return 0;
}
Quais recursos seriam usados para um programa que verifica se uma letra 
informada é uma vogal ou uma consoante?
I - Um if simples / II - Um if composto / III - Operador de igualdade (==) / IV 
- Operador && / V - Operador ||
RESP -> II, III e V - é um if composto (if or else) / operador de igualdade nas
vogais / operador OR
#include <iostream>
using namespace std;
int main (int argc, char** argv){
 char letra;
 cout<<"Digite uma letra:";
 cin>>letra;
 if 
((letra=='a')||(letra=='e')||(letra=='i')||(letra=='o')||(letra=='u')){
 cout<<"\nVogal";
 }
 else {
 cout<<"\nConsoante";
 }
 return 0;
}
Analise o trecho do programa em C++ e indique a alternativa correta:
Sendo A=62 e B=32, o que o programa vai imprimir?
int main (void){
 int A, B;
 cin>>B;
 cin>>A;
 if (A > B){
 B = A + B;
 }
 if (A < B){
 A = (B%2); 
 }
 cout<<A;
 }
Página 14
AL notas de aula.txt
 return 0;
}
RESP: 0 -> O primeiro if sendo executado, a variável B receberá a soma de A e B,
ou seja, 94, tornando B uma variável maior que A. Como não existe o else, o 
segundo if será executado, e como a condição dele é verdadeira, será executada o
segundo bloco de comando, modificando o valor da variável A para o resto da 
divisão de B por 2. Sendo B a valor obtido da soma no bloco de comando anterior,
94, o resta de sua divisão por 2 é 0. Portanto, o programa imprime 0, e não 62 
que seria o valor inicial de A.
Escolha a condição que fará o número 13 ser impresso:
int main (void){
 int num1, num2;
 num1 = 13;
 num2 = 22;
 if (_______){
 cout<<num2;
 else
 cout<<num1;
 }
 return 0;
}
Para o 13 ser impresso a condição tem que ser falsa. Nas alternativas, temos na 
E -> (num1<num2)&&(num2<20) 
A primeira é verdadeira (13<22) e a segunda falsa (22<20). Como temos o operador
&& (and) na expressão, ela só será verdadeira se as duas partes forem 
verdadeiras. Como a expressão é falsa, o else será excutado imprimindo o num1.
Analise as afirmativas abaixo e escolha a opção certa.
I Se tivermos que fazer um teste e só executar um bloco, que pode ter uma 
instrução ou mais instruções, o if simples deverá ser escolhido. 
II Se tivermos duas possibilidades de respostas, não poderemos usar dois if(s) 
simples, onde o teste de um é o complementa o do outro, porque poderão sair duas
respostas. 
III Se tivermos três possibilidades de respostas, podemos usar um if simples e 
um if composto que não teremos problemas com as respostas. 
IV Quando temos 10 possibilidades de respostas, poderemos usar 10 if(s) simples,
embora usar ifs encadeados seria mais eficiente.
RESPOSTA - I e IV são verdadeiras
TC: 63%
ALG - A6 _________________________________________________________________
NA: Estruturas de decisão em C++ >> if / if-else / switch / operador ternário
> “if-then-else” >> teste condicional de uma maneira completa: “se o teste for 
verdadeiro, então faça isso, senão faça aquilo”
>> p.e.:
Página 15
AL notas de aula.txt
 #include <iostream>
 ***#include BBPORTUGUES
 using namespace std;
 int main(void){
 int n;
 cout<<"Digite um número. Vou te dizer se ele é par ou ímpar"<<endl;
 cin>>n;
 if(n%2==0){
 cout<<"Número PAR."<<endl;
 }
 else{
 cout<<"Número ÍMPAR."<<endl;
 }
 system ("pause");
 return 0;
 }
> Operador ternário > Simplificando as linhas de comando IF ELSE, p.e.:
#include <iostream>
#include <locale.h>
 
 using namespace std;
 int main(void){
 int n;
 cout<<"Digite um número. Vou te dizer se ele é par ou ímpar"<<endl;
 cin>>n;
 (n%2==0)?cout<<"Numero PAR."<<endl:cout<<"Numero IMPAR."<<endl;
 system("pause");
 return 0;
 }
** operador existente em C++ e em outras linguagens, chamado de operador 
ternário. Ele é uma alternativa para substituir o desvio condicional composto em
algumas situações: 
 (condição)? verdadeiro : falso
 | | |
 aqui vai a condição | |
 quando a condição é verdadeira |
 expressão quando a condição é falsa, depois do :
> São três operandos: 
• A condição, que é o teste lógico usual, que é feito em toda estrutura de 
decisão
• Valor quando verdadeiro, que é a expressão ou valor a ser atribuído a uma 
Página 16
AL notas de aula.txt
variável quando a condição for verdadeira / Tudo o que vier após a interrogação 
“?” e antes do “:” será executado / Detalhe: neste espaço, somente um comando é 
permitido
• Valor quando falso: é a expressão ou valor a ser atribuído a uma variável 
quando a condição for falsa / Tudo o que vier após o “:” e antes do final da 
linha “;” será executado / Também só é permitido um comando
>> Esse operador também é útil quando vamos atribuir um valor a uma variável 
como resultado de um if:
 if (x == 10) // Se x for igual a 10
 y = 20; // então faço y receber valor 20
 else 
 y = 30; // senão faço y receber valor 30
Usando o operador condicional ternário, poderíamos escrever: 
y = (x == 10) ? 20 : 30; // y recebe, se x for igual a 10 então 20, senão 30
> aninhamento ou encadeamento de ifs >> colocar um if dentro do outro >> é usado
em várias linguagens de programação e também com outros comandos -> ver arquivo 
a06_t04.pdf
> p.e. >> imagine um programa no qual o usuário informa um mês, e o programa 
devolve se o mês tem 30 ou 31 dias. Como você faria esse programa?
“Vou ter que ler o número do mês”.
“Se for janeiro, tem 31 dias”.
“Se for fevereiro, pode ter 28 ou 29 dias. Se o ano for bissexto, tem 29; senão,
tem 28. Bem, mas acho que desta vez, eu vou considerar que tem 28 dias, só pra 
facilitar”.
“Se for março, tem 31”.
“Abril tem 30”, “maio tem 31”, “se for junho, então são 30”... “e se for 
dezembro, tem 31”.
“Caramba, vai ser um monte de ifs!”.
> Switch >> solução para o programa dos meses -> ver arquivo a06_t05.pdf
> exemplo de sintaxe do switch:
switch (variável){
 case constante1:
 Instruções;
 break;
 case constante2:
 Instruções;
 break;
 default:
 Instruções;
}
>> usado para substituir vários ifs e deixar o código mais legível
Página 17
AL notas de aula.txt
>> Também é bastante usado em estruturas de menu / Porém, temos uma limitação: o
comando não pode ser usado para avaliar expressões relacionais / Ele só funciona
quando comparamos com um valor constante e, quando a comparação é verdadeira, um
bloco de comandos é executado
** É muito importante usar o comando break após cada bloco de execução do case 
-> O comando break interrompe o switch e o programa volta ao fluxo de execução 
após o fechamento do comando switch
> retomando o programa dos meses -> se o usuário digitar um mês negativo ou 
outro valor [29, p.e.] que não esteja dentro das cláusulas case [valores de 1 a 
12], o programa executa corretamente a cláusula default, mas imprime na tela a 
mensagem da linha 51 ["O mês 29 tem 0 dias."] 
> Seria melhor que essa linha não fosse impressa quando o valor for inválido. E 
agora?
> Em C++, temos três operadores:
• O operador E, representado pelos caracteres &&;
• O operador OU, escrito como || em C;
• O operador de negação, representado pelo caractere ! (ponto de exclamação)
>> No exemplo dos meses, precisamos criar uma condição que não deixe que o 
programa aceite valores abaixo de 1 E acima de 12 
>> Se fosse nas aulas de Matemática, seria fácil: poderíamos criar uma expressão
assim: 
1<=mês<=12
>> Em C++, precisamos transformar essa condição de acordo com a sintaxe da 
linguagem: (mes>=1) && (mes<=12)
> Solução >> o programa verifica a entrada do usuário e, dependendo do númeroque ele inserir, que corresponde a um mês específico, será retornada a 
quantidade de dias do mês escolhido
>> Como não existe mês maior que 12 nem negativo, precisamos barrar estes 
valores e não permitir que o programa seja executado
>> Existem várias formas de se fazer isso, mas vamos usar uma com o if e com o 
switch, por meio de operadores lógicos -> ver arquivo a06_t07.pdf
 10 if ((mes>=1)&&(mes<=12)){ 
>> Como vemos, na linha 10 é feito um teste: se o valor da variável mês estiver 
entre 1 e 12, o switch é executado; caso contrário, o programa não imprimirá 
nada na tela
** Você pode perceber que, mesmo assim, deixamos o default na linha 48 / Embora 
tenhamos a certeza de que o programa não alcançará esta linha quando o valor 
estiver fora do intervalo, é bom deixá-la, em favor das boas práticas de 
programação
> Outra solução >> colocar uma instrução na clásula default para informar o 
usuário que o valor é inválido -> ver arquivo a06_t08a.pdf
 
 53 if(!invalido){
 54 cout<<"O mês "<<mes<<" tem "<<dias<<" dias.";
Página 18
AL notas de aula.txt
> numero++ -> significa que o número deve ser incrementado, ou seja, somar 1:
>> p.e. numero = 7; 
 cout<<numero++<<endl;
 saída será "8" 
> numero-- -> significa que o número deve ser decrementado, ou seja, subtrair 
1:
>> p.e. numero = 7; 
 cout<<numero--<<endl;
 saída será "6"
VA: > Alternativas em relação ao desvios condicionais >> operador ternário (pode
dificultar a leitura da programação, em if-else é mais fácil)
>> pode aparecer em C, C++, Java...
> aninhando ifs, p.e: um programa com duas variáveis: o gênero e a idade
IF >> se é homem ou mulher maior ou igual a 18 --> "pode dirigir" 
 IF >> se é homem maior ou igual a 18 --> "tem de fazer serviço militar"
ELSE >> se for homem ou mulher menor que 18
 IF >> se é homem ou mulher maior ou igual a 16 --> "pode votar"
 ELSE >> se é homem ou mulher menor que 16 --> "não pode votar e" "nem 
dirigir"
> exemplo switch:
#include <cstdlib>
#include <iostream>
using namespace std;
int main (int argc, char *argv[]){
 int valor = 4
 switch (valor){
 case 0;
 cout<<"Valor e igual a 0"<<endl;
 break;
 case 1;
 cout<<"Valor e igual a 1"<<endl;
 break;
 case 2;
 cout<<"Valor e igual a 2"<<endl;
 break;
 default:
 cout<<"Nenhuma das anteriores"<<endl;
 }
 system("pause")
 return EXIT_SUCCESS;
}
> Dominar os operadores lógicos: || OR && AND ! NOT
> Operadores de incremento ++ e decremento -- >> Pós e pré:
>> ++ >> significa incrementar o valor da variável com 1 e tem o mesmo 
significado de x=x+1 e de x += 1
Página 19
AL notas de aula.txt
> Pós var++ >> Significa que o valor é copiado antes de ser incrementado de 1 
(no final da equação)
> Pré ++var >> Significa incrementar primeiro valor da variável de 1 (antes de 
tudo)
>> -- >> significa decrementar o valor da variável de 1 e tem o mesmo 
significado de x=x-1 e de x -= 1
> Pós var-- >> Significa que o valor é copiado antes de ser decrementado de 1 
(no final da equação)
> Pré --var >> Significa decrementar primeiro valor da variável de 1 (antes de 
tudo)
>> p.e.:
#include <iostream>
#include <cstdlib>
 using namespace std;
 int main()
 {
 int a,b,c,d;
 a = 3; cout << "\nValor de a: " << a << endl; //EXIBE 3
 b =a++; //Copia primeiro e depois a
é incrementado **ordem importa
 cout << "\nValor de b: " << b << endl; //EXIBE 3
 cout << "\nValor de a: " << a << endl; //EXIBE 4
 c=8;cout << "\nValor de c: " << c << endl; //EXIBE 8
 d =--c; //Decrementa primeiro e 
depois uma cópia é armazenada
 cout << "\nValor de d: " << d << endl; //EXIBE 7 
 cout << "\nValor de c: " << c << endl; //EXIBE 7
 system("pause");
 return EXIT_SUCCESS;
 }
/*SAÍDA
Valor de a: 3
Valor de b: 3
Valor de a: 4
Valor de c: 8
Valor de d: 7
Valor de c: 7
Pressione qualquer tecla para continuar. . .*/
>> mais exemplo:
#include <iostream>
#include <cstdlib>
Página 20
AL notas de aula.txt
 using namespace std;
 int main()
 { int x, i;
 x = 3;
 cout << x<<" "; //EXIBE 3
 i = 6;
 x = x++ + i; //O valor de x [3] é somado ao de i [6] = 9, e depois 
incrementado de 1 [9+1] = 10
 cout << x<<" "; //EXIBE 10
 if ( x <= 7) //Não é menor que o 7. Logo, vai para o ELSE
 {
 cout << x<<" ";
 x = x + 10;
 }
 else
 cout<< ++x; //Primeiro, x é incrementado de 1 [10+1]. Logo, EXIBE 
11
 system("pause");
 return EXIT_SUCCESS;
 }
/* SAÍDA 3 10 11 Pressione qualquer tecla para continuar. . .*/
AT: > O que o seguinte programa imprime na tela? Suponha que:
 int main (void){
 int numero = 7;
 numero >=0 ? numero++ : numero--;
 cout<<"O novo valor e:"<<numero<<endl;
 return 0;
 }
RESPOSTA: 8
> Quando estudamos sobre a estrutura do se ... entao...senao, sempre nos é dito 
que, quando tivermos duas possibilidades de respostas, devemos escolher a 
estrutura do se composto ao invés de usar duas estruturas do se simples.
Observe as afirmativas abaixo e, depois, escolha a resposta que respalda o uso 
do se composto pelo que foi dito acima ao invés do se simples.
I Maior clareza no código, mas não influência na eficiência do mesmo
II Maior eficiência porque diminui o número de testes no código (RESPOSTA 
CORRETA)
III Maior eficiência somente porque o código fica mais legível, visto que o 
resultado final é o mesmo
IV Somente uma escolha do desenvolvedor, visto que o resultado o resultado final
é o mesmo
> Verifique o trecho de código abaixo e marque a alternativa que apresenta a 
melhor construção para as condições abaixo, utilizando uma estrutura de decisão 
composta.
if(a > 0) cout < < "pertinente";
if(a < 5) cout < < "pertinente";
if(a > =5) cout < < "não pertinente";
Página 21
AL notas de aula.txt
 Err. if(a > 0 || a < 5) cout < < "pertinente";
 else cout < < " não pertinente";
 Cor. if(a > 0 && a < 5) cout < < "pertinente";
 else cout < < " não pertinente";
> Considere o trecho de programa em C++. O que é impresso na tela? 
int x = 10, y = 3, z, k; 
y = x + y - 1; 
z = x/y; 
k = y % x; 
if ( k != 0) 
cout << "x = " << x << " y = " << y << " z = " << z << " k = " << k << "\n"; 
RESPOSTA x = 10 y = 12 z = 0 k = 2
TC: 75%
ALG - A7 _________________________________________________________________
NA: > estruturas de repetição > na programação, cada repetição é chamada de laço
ou loop 
> a estrutura FOR é muito usada nas repetições, principalmente nas ocasiões nas 
quais sabemos a quantidade de repetições que ocorrerão > 
Esse tipo de repetição é chamada de repetição controlada por contador, pois 
teremos uma variável que determinará o número de repetições daquela parte do 
programa -> esta variável tem que ser inteira
> ver arquivo a07_t03.pdf
>> a sintaxe do for em C++:
 for(inicialização ; condição ; incremento) <comandos>
> O comando for em C++ é composto por três partes, e cada uma delas é separada 
por ponto e vírgula:
>> Inicialização: declaramos uma variável do tipo inteiro (sempre) e atribuímos 
um valor inicial
>> Condição: é uma expressão relacional que determina quando a repetição acaba 
-> Quando a condição se tornar falsa, a execução do programa continua no comando
seguinte ao for
>> Incremento: configura como a variável de controle da repetição varia cada vez
que a repetição é executada. Pode ser positivo ou negativo.
> p.e > um programa que conta de 1 a 10: 
#include <iostream>
using namespace std;
 int main (void){
 for (int i=1; 1<=10; i++)
 cout<<i<<", ";
 return 0;
}
Página 22
AL notas de aula.txt
>> mais exemplosde aplicação do for:
1) Alterar a variável de controle de 1 a 100 incrementando de 1
 >> for (int i=1; i<=100; i++)
2) Alterar a variável de controle de 100 a 1 em decrementos de 1 >> 
for (int i=100; i>=1; i--)
3) Alterar a variável de controle de 8 a 88 em incrementos de 8
 >> for (int i=8; i<=88; i+=8)
4) Alterar a variável de controle de 20 a 2 em decrementos de 2
 >> for (int i=20; i>=2; i-=2)
5) Alterar a variável de controle sobre uma sequência de valores - p.e: 
2,5,8,11,14,17,20 >> 
for (int i=2; i<=20; i+=3)
6) Alterar a variável de controle sobre uma sequência de valores - p.e: 
99,88,77,66,55,44,33,22,11,0
 >> for (int i=99; i>=0; i -=11)
> p.e > um programa que soma valores: 
#include <iostream>
using namespace std;
 int main (void){
 int total = 0; /* <- simplificação de duas linhas: int total; 
total = 0; [valor incial da variável]*/
 for (int n=2; n<=20; n+=2){ /*variável=int começa com 2; termina com 20; 
incremento de 2*/
 total +=n; /*soma o resultado com a variável -> total = 
total + n*/
 }
 cout<<"Soma = "<<total; 
 return 0;
}
SOLUÇÃO: ??? ***DUVIDA
> ver arquivo a07_t04.pdf
VA: > tipo de estrutura de controle > repetição ou looping
> estrutura >> for > significa para 
> operadores >> incremento ou decremento > operadores do tipo unário
> sintaxe for >> for (declaração de variável que vai contar as vezes de 
repetição condição inicial; condição de parada ou final; operador){ mais de um 
comando a chave é obrigatória }
> p.e. >> for (int i=1; i<=10; i++)
 int -> variável inteira
Página 23
AL notas de aula.txt
 i=1 -> condição inicial
 i<=10 -> condição final
 i++ -> incremento de 1
>> pré incremento: incrementa o valor de n por 1 (soma 1) e depois usa o novo 
valor de n na expressão em que reside n
>> pós incremento: usa o valor atual de n na expressão em que reside n e depois 
incrementa por 1 no resultado
> p.e.
#include <iostream>
using namespace std;
 int main (void){
 int i;
 i=5;
 cout<<i<<endl; /*primeira saída é o valor puro do i -> 5*/
 cout<<i++<<endl; /*pós incremento, por isso o valor primeiro é 
apresentado igual -> 5*/
 cout<<i<<endl; /*nessa saída o valor é o resultado do pós 
incremento -> 6*/
 cout<<"----------"<<endl; /*saída mostra os traços para dividir a tela*/
 i=5;
 cout<<i<<endl; /*primeira saída é o valor puro do i -> 5*/
 cout<<++i<<endl; /*pré incremento, por isso o valor primeiro já é 
apresentado com a soma -> 6*/
 cout<<i<<endl; /*nessa saída o valor é o i mais recente, mantendo
o resultado do incremento -> 6*/ 
 return 0;
}
>> para incrementar em 2 -> i+=2 [traduzindo, i = i + 2]
 " " " 3 -> i+=3 [que seria, i = i + 3] e assim por diante
>> ou seja, para incrementar em n -> variável+=n
>> p.e: supondo x=4, y=6, z=5, w=7, t=13
 x+=7 -> x = x + 7 -> x=11
 y-=4 -> y = y - 4 -> y=2
 z*=5 -> z = z * 5 -> z=25
 w/=7 -> w = w / 7 -> w=1
 t%=4 -> t = t % 4 -> t=1
AT: > int conta, num = 1, prod = 1; 
 for (conta = 4; conta > 0; conta--) { 
 prod = prod *num; 
 num++; 
 } 
 cout << "Prod = " << prod << " num = " << num << endl; 
Página 24
AL notas de aula.txt
RESPOSTA
num = 1, prod = 1;
Declara as variáveis e inicializa prod e num com 1 
for (conta = 4; conta > 0; conta--) {
Primeira VEZ, conta =4
Segunda VEZ, conta =3 
Terceira VEZ, conta =2
Quarta VEZ, conta =1 
e Depois para em 0
prod = prod *num;
Primeira VEZ, prod = 1 * 1 logo, prod = 1 
Segunda VEZ, prod= 1 * 2 logo, prod = 2 
Terceira VEZ, prod= 2 * 3 logo, prod = 6 
Quarta VEZ, prod= 6 * 4 logo, prod = 24 
num++;
Primeira VEZ, num=2 
Segunda VEZ, num=3
Terceira VEZ, num=4 
Quarta VEZ, num=5 
 
cout << "Prod = " << prod << " num = " << num << endl; 
EXIBE Prod = 24 num = 5
> Marque a opção correta. Considere o trecho de programa feito em C++. O valor 
final de s e o valor final de num, são respectivamente: 
 int conta, num=1, s=0; 
 for(conta = 10; conta < = 40; 
 conta= conta+10){ 
 s= s+num; num= num +2; 
 }
RESPOSTA: Analisando o código, percebemos que temos uma estrutura de repetição 
onde a variável conta foi inicializada com 10, 
irá repetir até 40 e está sendo incrementada de 10 em 10
Temos duas linhas de comandos que estão sendo executadas dentro da estrutura de 
repetição
Uma linha de comando é uma variável acumuladora, ou seja, está somando os 
valores que estão armazenados em num 
e a outra linha de comando está incrementando a variável num de dois em dois 
então, 
vejamos o teste de mesa: 
Inicialmente temos os seguintes valores: S = 0 Num = 1 
 A variável conta = 10 S = 1 num = 3
 A variável conta = 20 S = 4 num = 5 
 A variável conta = 30 S = 9 num = 7 
 A variável conta = 40 s = 16 num = 9 
Quando a repetição for encerrada, teremos armazenados os valores na variável s =
16 e na variável num = 9
Página 25
AL notas de aula.txt
> int x; 
for (x = 5; x > 0; x--) 
if (x % 3 == 0) 
cout << x - 1 << " "; 
else 
cout << x + 1 << " "; 
RESPOSTA: O for é uma estrutura de repetição controlada por uma variável 
contadora
Sua estrutura é: para ( ; ; ) { < bloco de comandos > } 
O programa que gerou a dúvida temos: for (x = 5; x > 0; x--) 
Ou seja, a variável x foi inicializada com o valor 5, 
a repetição será enquanto o valor de x for maior que zero e será decrementado de
1 em 1
Quando x = 5, faremos: 
if (x % 3 == 0) , 5 % 3 ( o resto da divisão será 2) 2 == 0, o resultado lógico 
é falso então,
executaremos a linha de comando do else: 
cout << x + 1 << " "; 
Será impresso na tela 6 ( 5 + 1), e também será impresso um espaço
Quando x = 4, faremos: if (x % 3 == 0) , 4 % 3 ( o resto da divisão será 1) 1 ==
0, 
o resultado lógico é falso então, executaremos a linha de comando do else: 
cout << x + 1 << " "; 
Será impresso na tela 5 ( 4 + 1), e também será impresso um espaço
Quando x = 3, faremos: if (x % 3 == 0) , 3 % 3 ( o resto da divisão será 0) 0 ==
0, 
o resultado lógico é verdadeiro então, executaremos a linha de comando: 
cout << x - 1 << " "; 
Será impresso na tela 2 (3 - 1), e também será impresso um espaço
Quando x = 2, faremos: if (x % 3 == 0) , 2 % 3 ( o resto da divisão será 2) 2 ==
0, 
o resultado lógico é falso então, executaremos a linha de comando: 
cout << x + 1 << " "; 
Será impresso na tela 3 (2 + 1), e também será impresso um espaço
Quando x = 1, faremos: if (x % 3 == 0) , 1 % 3 ( o resto da divisão será 1) 1 ==
0, 
o resultado lógico é falso então, executaremos a linha de comando: 
cout << x + 1 << " "; 
Será impresso na tela 2 (1 + 1), e também será impresso um espaço
Quando x = 0, para a repetição, pois zero não é maior que zero 
Logo foi impresso na tela os valores: 6 5 2 3 2
** Considere a estrutura for ( ; ; ), e assinale a afirmação correta: 
É um laço infinito. >> Então simplesmente o formato for ( ; ; ) pode ser 
considerado um loop infinito 
RESPOSTA: A estrutura do for tem a seguinte sintaxe: 
 para ( ; ; ) { < bloco de comandos > } 
Quando colocamos os parâmetros no for, p.e. for( x = 1 ; x <= 10; x++) 
-> estamos dizendo que a variável contadora x começa com o valor 1 e irá repetir
enquanto x for menor ou igual a 10
Página 26
AL notas de aula.txt
Sendo incrementada de um em um
>> Mas quando não colocamos parâmetros: for ( ; ; )
-> teremos um laço infinito, pois não tem a variável contadora sendo 
inicializada, 
não tem a condição e não tem o incremento ou decremento então, 
teremos uma repetição infinita
> Leia atentamente o trecho de código abaixo e diga o que ele retornaria ao 
usuário: 
 int main ( ) { 
 int i; 
 double x, y = 0; 
 for (i = 0; i< 10; i++){ 
 cout << "Digite um numero: "; 
 cin >> x; 
 if ((x % 2) == 1){ 
 y = y + x; } 
 cout << "Numero: " << y << "\n"; 
 system("PAUSE"); 
 return 0;
 }
 O maior de todos os elementos digitados 
 A soma de todos os elementos 
 A soma dos elementos ímpares 
 A média dos elementos digitados 
 A quantidade de elementos digitados
> Leia atentamente o trecho de código abaixo e diga o que ele retornaria ao 
usuário:
 int main ( ) {
 int i = 0;
 double x, y = 0;
 cout << "Digite um numero: ";
 cin >> x;
 while (x != 0){
 i = i + 1;
 y = y + x;
 cout << "Digite um numero: ";
 cin >> x;
 }
 y = y / i;
 cout << "Numero: " << y << "\n";
 system("PAUSE");
 return 0;
 }
 Cor. A média dos elementos digitados
> Leia atentamente o trecho de código abaixo e diga o que ele retornaria ao 
usuário:
Página 27
AL notas de aula.txt
 int main ( ) {
 int i = 0;
 double x, y = 0;
 cout << "Digite um numero: ";
 cin >> x;
 while (x != 0){
 i = i + 1;
 y = y + x;
 cout << "Digite um numero: ";
 cin >> x;
 }
 y = y / i;
 cout << "Numero: " << x << "\n";
 system("PAUSE");
 return 0;
 }
 Cer. O último digitado, ou seja, zero
> Leia atentamente o trecho de código abaixo e diga o que ele retornaria ao 
usuário:
 int main ( ) {
 int i = 0;
 double x, y = 0;
 cout << "Digite um numero: ";
 cin >> x;
 while (x != 0){
 i = i + 1;
 y = y + x;
 cout << "Digite um numero: ";
 cin >> x;
 }
 y = y / i;
 cout << "Numero: " << i << "\n";
 system("PAUSE");
 return 0;
 }
 Cer. A quantidade de elementos digitados
RESPOSTA: A variável i é um contador que é incrementado de 1 
e como está dentro do bloco que será repetido pela estrutura while() enquanto x 
for diferente de 0, 
ele será incrementado toda vez que um número diferente de 0 for digitado
Logo, i contem, ao final a quantidade de números digitados.
TC: 63%
ALG - A8 _________________________________________________________________
NA: > estruturas de repetição 
> o for tem uma peculiaridade: ele é usado quando sabemos o número de vezes que 
uma repetição será executada
> Repetição com Limite do Contador Determinado pelo Usuário >> o usuário que 
Página 28
AL notas de aula.txt
determina a condição final >> com o comando o while (enquanto) 
>> sintaxe:
 while (<condição>) {
 <bloco de comandos>
 }
> no exemplo a seguir, o fluxo chega a uma condição (decisão) no qual será 
avaliada:
 _ _
 | | <__________________________________________________ 
 
 ->>| decisão | __> [verdadeira] _______> [instrução executada] ___|
 |_ _| __> [falsa] _________________________________________> 
[segue o programa]
>> Se for verdadeira, o fluxo passa para as instruções a serem executadas e 
volta à condição 
 [looping -> Enquanto a condição for verdadeira, o fluxo ficará “preso” a esse
laço] 
>> Quando a condição for falsa, então ele se liberta e continua o programa
>> Portanto, evite criar condições que deixem o programa preso para sempre no 
looping [looping infinito]
>> p.e. >> folha de pagamento -> 
O algoritmo consiste em ler do usuário um número de funcionários, que será o 
contador -> Para cada funcionário, será pedido o salário mensal, e este valor 
será somado ao valor da folha:
1 #include <iostream>
2 using namespace std;
3
4 int main (void){
5 int num_funcionarios, i=1; */i=1 -> significa 
inicializar o contador em 1/*
6 float salario, valor_folha=0; */valor_folha=0 -> valor 
inicial da folha em 0/*
7
8 cout<<"Digite o número de funcionários da empresa"<<endl;
9 cin>>num_funcionarios;
10
11 while (i<=num_funcionarios){ */i<=num_funcionarios -> 
condição para repetir/*
12 cout<<"Funcionario "<<i<<". Qual o salário deste 
funcionário?"<<endl;
13 cin>>salario; 
14 valor_folha+=salario; */ valor_folha = 
valor_folha + salario/*
15 i++; */nunca esquecer de 
incrementar o valor do contador... /* 
16 } 
Página 29
AL notas de aula.txt
*/...evita o looping infinito/*
17 cout<<"Valor da folha de pagamento: R$"<<valor_folha;
18 return 0;
19 }
** Veja que, na linha 11 até a 16, temos o while sendo controlado por uma 
variável que o usuário digitou
 Se o usuário digitar 800, teremos 800 repetições (800 funcionários); se 
digitarmos 8, teremos 8 repetições e assim por diante
 A linha 15 é muito importante e muitas vezes é esquecida pelos iniciantes
 Sem ela, o looping cairá numa repetição infinita, o que, mais uma vez, é tudo
o que não queremos
 Nunca se esqueça de colocar dentro de um while a alteração da variável de 
controle!
 A cada repetição, a variável valor_folha é incrementada com o valor do 
salário lido
 Veja a linha 14 e olhe o operador += que foi usado
 Lembra-se dele, né? Para recordar, ele faz o mesmo que valor_folha = 
valor_folha + salario
 Observe também o operador de incremento na linha 15
 Ver -> oc8_programa folha salario.png
> outro tipo de repetição >> quando a repetição não é controlada pelo 
programador nem pelo usuário, mas o próprio programa
> p.e. >> O MDC [máximo divisor comum] -> MDC entre 12 e 18, é representado por:
MDC (12,18) = 6
>> exemplo de uso: 
Uma indústria de tecidos fabrica retalhos de mesmo comprimento. Após realizarem 
os cortes necessários, verificou-se que duas peças restantes tinham as seguintes
medidas: 156 centímetros e 234 centímetros. O funcionário deve cortar o pano em 
partes iguais e de maior comprimento possível. Como ele poderá resolver essa 
situação?
 Simples: com o MDC dos números 156 e 234
>> pelo comando do-while -> O seu objetivo é avaliar uma condição após um bloco 
de programação >> Se a condição for verdadeira, o loop repete; se for falsa, o 
loop para e prossegue com o fluxo do programa
>> A sintaxe do comando é assim:
 do {
 comando;
 comando;
 ...
 } while (condição);
>> Veja que obrigatoriamente pelo menos uma vez o bloco será executado -> Esta é
a maior característica dessa estrutura * ver -> a08_t04.pdf
> programa MDC:
1 #include <iostream>
2 using namespace std;
Página 30
AL notas de aula.txt
3
4 int main (void){
 5 int num1, num2, resto;
 6 cout<<"Digite dois números, em ordem crescente"<<endl;
 7 cin>>num1;
 8 cin>>num2;
9
 10 do {
11 resto = num2%num1;
 12 cout<<"Numero 2 = "<<num2<<" - Numero 1 = "<<num2<<" - Resto = 
"<<resto<<endl;
13 num2 = num1;
 14 num1 = resto;
 15 } while(num1>0);
 16 cout<<"MDC = "<<num2;
 17 return 0;
18 }
> Repetição Controlada pelo Valor da Entrada de Dados >> Esta é uma variação da 
estrutura que vimos usando o for >> Com o for, percebemos que ele é adequado 
para situações em que o número de repetições é bem definido e conhecido >> 
Agora vamos ver uma variação desse tipo de estrutura, porém usando o comando 
while
> Um bom exemplo é o cálculo do pi usando uma série infinita, chamada de série 
de Gregory-Leibniz **ver -> a08_t05.pdf
* Temos um detalhe: a série de Gregory-Leibniz só funciona bem com no mínimo 
500.000 repetições / Você pode pensar que demoraria para retornar o resultado, 
mas isto vai depender do seu computador / Se o seu computador tiver um bom 
processador, com bastante memória RAM, em pouquíssimos segundos o resultado irá 
aparecer
> Repetição Controlada pela Respostado Usuário >> No exemplo foi criado um menu
de um programa que ficará em execução até que a tecla ‘0’ seja pressionada *ver 
-> a08_t06.pdf
>> o programa “gira” em torno de uma estrutura do-while até a condição de 
controle pela resposta (opcao!=0) -> o usuário deve digitar '0'
>> O menu é implementado por uma estrutura switch e, dependendo da opção 
escolhida pelo usuário, o case correspondente será executado
>> Em todos os cases, exceto o 3 [“Repetir o menu”], existe um comando que até 
agora não foi usado, o system(“cls”) -> Como você percebeu, a finalidade dele é 
apagar a tela para que novas informações sejam impressas / Ele dá um efeito 
visual simples e bastante bacana para o programa
>> O maior ensinamento desse exemplo é mostrar que a repetição é controlada pela
resposta do usuário e a opção digitada pelo usuário mostra isso e determina a 
quantidade de vezes que o programa será executado
> loopings aninhados >> Em várias situações, é necessário criar um algoritmo de 
repetição dentro do qual há outra repetição >> possíveis sintaxes:
>> Com o comando for
Página 31
AL notas de aula.txt
for (início; condição; incremento){
 for (início; condição; incremento){
 comandos
 }
 comandos
}
>> Com o comando while
while (condição){
 while (condição){
 comandos
 }
 comandos
}
>> Com o comando do-while
do {
 comandos
 do {
 comandos
 } while (condição);
} while (condição);
*ver ex -> a08_t07.pdf
*** fazer o programa -> a08_t08.pdf
VA: > programação estruturada tem três tipos >> estrutura sequencial / 
estrutura de decisão / estrutura de repetição
> em repetição vemos dois comandos na aula: while e do-while
> while = enquanto -> enquanto uma condição for verdadeira, o bloco de comandos 
será executado
>> é utilizado em situações em que se não sabe o número de repetições
> do-while = faça enquanto -> primeiro o bloco de comandos será executado e a 
condição é testada no final > se a condição for satisfeita, ele volta a execução
do bloco (looping) -> o teste é feito no FIM do programa
>> é utilizado em situações em que se não sabe o número de repetições, mas 
obrigatoriamente terá ao menos uma repetição
** o FOR é utilizado quando já conhecemos o número de repetições que serão 
feitas
AT: > O seguinte código deve imprimir os valores de 1 a 10:
 
 n=1;
 while (n<10)
 cout<<n++;
RESP - Não, a condição correta para imprimir de 1 a 10 é n<=10
Página 32
AL notas de aula.txt
 > *ver -> al8_representacao while dowhile for.png
 >* No comando do-while, a expressão lógica associada ao while é avaliada 
após a execução do bloco de comandos; no while-do, a expressão lógica de 
controle é avaliada antes >> a expressão lógica do while é avaliada em primeiro 
lugar e, depois, se for verdadeira, executa o bloco. No do-while, a expressão 
lógica é avaliada após o bloco
> Leia atentamente o trecho de código abaixo e diga o que ele retornaria ao 
usuário:
int main ( ) {
 int i = 0;
 double x, y = 0;
 cout << "Digite um numero: ";
 cin >> x;
 while (x != 0){
 i = i + 1;
 y = y + x;
 cout << "Digite um numero: ";
 cin >> x;
 }
 y = y / i;
 cout << "Numero: " << i << "\n";
 system("PAUSE");
 return 0;
}
RESPOSTA = A quantidade de elementos digitados
> Leia atentamente o trecho de código abaixo e diga o que ele retornaria ao 
usuário:
int main ( ) {
 int i = 0;
 double x, y = 0;
 cout << "Digite um numero: ";
 cin >> x;
 while (x != 0){
 i = i + 1;
 y = y + x;
 cout << "Digite um numero: ";
 cin >> x;
 }
 y = y / i;
 cout << "Numero: " << x << "\n";
 system("PAUSE");
 return 0;
}
RESPOSTA = O último digitado, ou seja, zero
> Considere o trecho abaixo sabendo que num é um variável inteira.
Página 33
AL notas de aula.txt
num = 11;
do {
 if (num % 2 == 0)
 cout << num << "\n";
 num = num -1 ;
} while (num != 0);
RESPOSTA: O trecho fornecido pára quando num for zero e os números exibidos são 
todos os pares de 10 até 2, nesta ordem
> Leia atentamente o trecho de código abaixo e diga o que ele retornaria ao 
usuário:
int main ( ) {
 int i = 0;
 double x, y = 0;
 cout << "Digite um numero: ";
 cin >> x;
 while (x != 0){
 i = i + 1;
 y = y + x;
 cout << "Digite um numero: ";
 cin >> x;
 }
 y = y / i;
 cout << "Numero: " << y << "\n";
 system("PAUSE");
 return 0;
}
RESPOSTA = A média dos elementos digitados
> As estruturas de repetição permitem executar mais de uma vez um mesmo trecho 
de código. Trata-se de uma forma de executar blocos de comandos somente sob 
determinadas condições, mas com a opção de repetir o mesmo bloco quantas vezes 
forem necessárias. As estruturas de repetição são úteis, por exemplo, para 
repetir uma série de operações semelhantes que são executadas para todos os 
elementos de uma lista ou de uma tabela de dados, ou simplesmente para repetir 
um mesmo processamento até que uma certa condição seja satisfeita. Sejam as 
seguintes afirmativas:
I - Toda estrutura de repetição apresenta um teste no início e um na saída.
II - Toda estrutura de repetição pode ser substituída por um conjunto de 
estruturas de decisão, onde não haja testes ou condições.
III - Toda estrutura de repetição apresenta um critério de parada.
IV- Toda estrutura de repetição apresenta fluxo de execução invertido devido a
diversas interações.
Marque a alternativa que representa apenas as afirmativas CORRETAS: 
RESPOSTA = somente a III
> Assinale a alternativa correta em relação a quantidade de vezes que a palavra 
Página 34
AL notas de aula.txt
"PAZ" será impressa, no trecho de código abaixo: 
x = 50;
do{
y = 8;
do{
cout<<"PAZ \n";
y++;
} while ( y < 10);
x--;
} while ( x > 48);
RESPOSTA = 4 vezes
TC: 56%
ALG - A9 _________________________________________________________________
NA: > Um dos grandes objetivos da programação de computadores é criar programas 
simples e que sejam facilmente entendidos por outras pessoas > Porém, é muito 
comum que os programas tenham 500, 1000 ou mais linhas de código > Às vezes este
número é necessário; outras vezes percebemos que ele pode ser reduzido > Será 
que não existem partes de um programa que poderíamos separar e tratar como um 
programa à parte, ou um subprograma? Desta forma, toda vez que aquela parte 
fosse necessária, chamaríamos somente ela > 
Isso é possível e tem um nome: procedimentos e funções
> p.e. o funcionamento de um app de smartphone >> o celular funciona como um 
grande laço:
- Enquanto o botão de desligar não for acionado, espere algum comando do 
usuário;
- SE o ícone de fazer ligação for pressionado, ENTÃO abra a tela de chamadas;
- SE o ícone do navegador for pressionado, ENTÃO abra o navegador;
- E assim por diante.
>> Acontece que o programa do celular não é sequencial -> Não podemos prever o 
que o usuário vai fazer, então precisamos criar subprogramas que são chamados à 
medida que o usuário faz uma determinada ação
> Basicamente é isso que fazemos quando temos um programa muito grande e temos a
possibilidade de simplificá-lo: usando subprogramas, chamados de funções ou 
procedimentos
> o funcionamento de uma função ou procedimento >> O procedimento é um grupo de
comandos que realiza uma determinada tarefa específica que é executada quando o 
procedimento é chamado >> 
Quando o programa principal chama o procedimento, o fluxo do programa é desviado
para o procedimento, o qual é executado em seguida, e após a sua finalização, o 
procedimento volta à execução do programa principal normalmente
> o comando system(“cls”) é um procedimento
>> p.e. -> No código a seguir, o programa segue oseu fluxo normal, imprime a 
mensagem “Digite o seu nome”, lê o valor do usuário e chama em seguida o 
Página 35
AL notas de aula.txt
procedimento system(“cls”)
cout<<”Digite o seu nome: “<<endl;
cin>>nome;
system(“cls”);
cout<<”Ola “<<nome<<”, tudo bem?”<<endl;
> Internamente, a execução do programa é interrompida, o fluxo é desviado para o
código do procedimento system(“cls”), o qual usa vários comandos internos para 
limpar a tela, e depois devolve o fluxo para o programa principal e imprime a 
mensagem “Olá... tudo bem?”
* É igual ao programa do celular do exemplo -> Parece que é um programa 
sequencial, não é? Mas, no fundo, um programa para celular é na verdade um 
grande looping cheio de chamadas a procedimentos específicos, como por exemplo, 
fazer ligação, navegar na internet, executar a calculadora, etc.
> Diferenças entre Funções e Procedimentos >> A função é um procedimento que 
possui obrigatoriamente um retorno / O procedimento não possui retorno
>> Lembra que o system(“cls”) é um procedimento? Que retorno ele devolve ao 
programa principal? Nenhum! Logo, é um procedimento
**Daqui para a frente, não vamos mais usar no nosso vocabulário de C++ a palavra
“procedimento” -> Uma vez que o procedimento é uma função, mas que não retorna 
valor, então vamos usar apenas “função”
> Porque usar Funções:
-> Para uma melhor legibilidade
-> Para modularizar o programa em partes menores e mais funcionais
-> Para melhorar a manutenção e permitir a alteração de uma determinada parte do
código de uma maneira mais rápida
-> Para evitar que uma parte do código seja repetida várias vezes em um programa
-> Para o reaproveitamento de código: uma função que você faz pode ser usada por
outro programador
> A sintaxe de uma função em C++ é a seguinte:
 Tipo_da_função nome_da_função(lista_de_parâmetros){
 Corpo 
da função
 }
>> Tipo da função -> configura um valor que a função retornará quando terminar /
O valor é enviado ao módulo que chamou a função / Caso o tipo da função não seja
especificado, o compilador assumirá que o tipo retornado é int
>> Lista de parâmetros -> é a relação de variáveis e seus tipos / Ela é 
opcional, não é toda função que tem parâmetros
> ver exemplo de programa -> a09_t06.pdf
* A função getch()
 tem como objetivo ler uma tecla digitada pelo usuário e retornar o valor 
numérico da tecla -> Cada tecla no computador tem um código ->> e o código da 
tecla “c” é 99 / A função getch() é definida na biblioteca conio.h, e para usar 
Página 36
AL notas de aula.txt
a função, é necessário incluir a biblioteca no programa
> Na função teclac() que fizemos, você deve ter notado que a chamada dela no 
programa principal é muito simples:
>> É como chamar a função getch(): basta usá-la e pronto!
>> Mas algumas funções precisam receber valores para serem executadas
>> Como já vimos, uma função para calcular a raiz quadrada de um número precisa 
receber o número para que a função seja executada
>> Algumas funções, como o exemplo do MDC, precisam de dois ou mais parâmetros, 
enfim, para a linguagem C++ ficar mais versátil, o uso de parâmetros é permitido
>> Os parâmetros possibilitam que seja definido sobre quais dados a função deve 
funcionar
> Para definir os parâmetros de uma função, é preciso que o tipo da variável 
seja declarado antes do nome da variável -> Se houver mais do que um, os outros 
parâmetros são separados por vírgulas >> p.e.:
void soma(float a, int b) {
 float result;
 result = a+b;
 cout<<"A soma de “<<a<<” e “<<b<<” eh “<<result;
 }
> ver exemplo de program -> a09_t07.pdf
> Os parâmetros da função, quando estão na declaração da função, são chamados de
parâmetros formais (como o float a, int b na função anterior) >> Na chamada da 
função, são chamados de parâmetros reais ou argumentos
> Preste atenção: os parâmetros devem ser passados de acordo com sua posição -> 
Ou seja, o tipo do primeiro argumento (na chamada) tem que “casar” com o tipo do
primeiro parâmetro formal (na declaração da função); o tipo do segundo argumento
“casa” com o segundo tipo do parâmetro formal, e assim por diante
>> Os nomes das variáveis da chamada e da declaração não precisam ser os mesmos
> Retorno de uma Função >> A função tem que fazer exatamente o que o nome dela 
propõe. Se estamos fazendo uma soma, então ela deveria fazer somente a soma, e o
resultado, o próprio programa principal se encarrega de fazer 
>> Porém, dessa forma vamos precisar que a função retorne um valor para quem a 
chamar (neste caso, o programa principal)
> Essa palavra é obrigatória para as funções que não retornam valor. As que 
retornam valor, no lugar da palavra void, terão que indicar o tipo do retorno, 
como mostra a função soma() no exemplo:
1 #include <iostream>
2 using namespace std;
3 */toda função aparece sempre antes do 
programa principal/*
4 float soma(int n1, float n2){ */a função recebe o valor da variável 
n1 [inteiro] e de n2 [float]/*
5 float resultado; */em seguida ele cria uma variável 
Página 37
AL notas de aula.txt
chamada resultado/*
6 resultado = n1+n2; */em resultado faz a conta [a soma no 
caso] entre n1 e n2/* 
7 return resultado; */toda vez que a função for iniciada 
com um tipo.../* 
8 } */... de variável obrigatoriamente tem 
que usar o return .../*
9 */... no final da função /*
10 int main (void){ */programa principal/*
11 int a = 100;
12 float b = 25.5;
13 float retorno; */cria uma variável chamada retorno/*
14 retorno = soma(a,b); */chamada da função no programa 
principal/*
15 cout<<"Valor da soma: "<<retorno;
16 }
>> Veja que agora a declaração da função, na linha 4, tem o tipo do retorno da 
função: float
>> E obrigatoriamente temos que ter a palavra reservada return dentro da função 
para indicar o valor que será devolvido como resultado da função
>> Nesse caso, o valor é devolvido e atribuído à variável retorno na linha 13
>> Portanto, quando não tiver valor de retorno, a função tem um void na sua 
declaração
>> Quando retornar algum valor, ela tem que ter o tipo do retorno e usar o 
return dentro da função
> O escopo de uma variável é o bloco de código onde a variável é válida. Desta 
forma, temos algumas considerações a fazer:
-> As variáveis são válidas nos blocos em que foram definidas
-> As variáveis que são definidas dentro de uma função são chamadas de variáveis
locais
-> Os parâmetros formais de uma função valem somente dentro da função
-> Uma variável que foi definida dentro de uma função não é acessível em outras 
funções, mesmo se os nomes forem exatamente iguais
> ver exemplo de program -> a09_t09.pdf
> o próprio programa principal em C++ é uma função -> Por isso usamos o return 0
no final dos programas: para retornar o valor 0 a quem chamou o programa; neste 
caso, o sistema operacional
>> O C++ possui milhares de funções predefinidas, e saber usá-las é muito 
importante -> Desta forma, evitamos a “reinvenção da roda”, como por exemplo, 
desenhar figuras de funções matemáticas, funções de estruturas de dados, de 
manipulação de strings etc
>> Já existe muita coisa pronta / Basta saber em qual biblioteca a função 
desejada se encontra e incluir a biblioteca corretamente dentro do programa / 
Como foi o caso da função getch()
> ver exemplo de program -> a09_t11.pdf
VA: programação modular > criação e uso