Dev C ++

QI - Escola de Educação Profissional
Apostila de Lógica de Programação
APOSTILA DE LÓGICA DE PROGRAMAÇÃO
Direitos autorais reservados à:

Professor Eduardo Reus Souza.
Escola QI – Porto Alegre
Professor: Eduardo Reus Souza 1

Sumário
Aula 1 ............................................................................................................................... 6
Apresentação da Disciplina .......................................................................................... 6
1. Considerações iniciais ...................................................................................... 6
1.1. Lógica e Lógica de Programação ................................................................. 6
1.2. Problema ....................................................................................................... 6
1.3. Algoritmo ..................................................................................................... 6
1.4. Programa....................................................................................................... 6
1.5. Formas de se representar um Algoritmo ...................................................... 6
1.6. Regras para a Criação de Algoritmos ........................................................... 7
1.7. Como proceder na construção de algoritmos? .............................................. 7
1.7.1. Leia com atenção o enunciado do problema ............................................ 7
1.7.2. Obtenha os dados de entrada .................................................................... 7
1.7.3. Obtenha os dados de saída ........................................................................ 8
1.7.4. Determinar o que deve ser feito para transformar as entradas
determinadas nas saídas especificadas ..................................................................... 8
1.7.5. Testar o algoritmo..................................................................................... 8
1.8. Exercícios propostos ..................................................................................... 8
2. Variáveis e Constantes de memória (RAM) ..................................................... 9
2.1. Memória ....................................................................................................... 9
2.2. Como um programa é tratado na memória? ................................................. 9
2.3. Variáveis ....................................................................................................... 9
2.4. Constantes..................................................................................................... 9
2.5. Regras para formação de Identificadores ..................................................... 9
2.6. Tipos de Dados ........................................................................................... 10
2.7. Principais tipos de dados utilizados na disciplina ...................................... 10
2.8. Exercícios Propostos .................................................................................. 10
Aula 2 ............................................................................................................................. 11
Começando a programar na Linguagem C ................................................................. 11
3. Linguagens de programação ........................................................................... 11
3.1. Linguagens de Baixo Nível ........................................................................ 11
3.2. Linguagens de Alto Nível ........................................................................... 11
3.3. Compilador ................................................................................................. 11
3.4. Estrutura padrão de um algoritmo (C) ........................................................ 11
3.5. Indentação..................................................... Erro! Indicador não definido.
3.6. Operadores aritméticos ............................................................................... 13
3.7. Regras de precedência de operadores ......................................................... 13
Aula 3 ............................................................................................................................. 14
3.9. Utilizando instruções de I/O ....................................................................... 14
3.10. Exercícios Propostos .............................................................................. 15
Aula 4 ............................................................................................................................. 17
Introdução ao DEV-C++ ............................................................................................ 17
4. Sobre o software ............................................................................................. 17
4.1. O que é DEV-C++? .................................................................................... 17
4.2. Versão do DEV-C++ .................................................................................. 17
4.3. Interface do Software.................................................................................. 17
4.4. Compilando um Projeto .............................................................................. 19
4.5. Tipos de Erros............................................................................................. 21

4.6. Exercício Proposto...................................................................................... 21
Aula 5 ............................................................................................................................. 22
Algoritmos Condicionais ............................................................................................ 22
5. Introdução ....................................................................................................... 22
5.1. Instrução IF (SE) ........................................................................................ 22
5.2. Operadores Relacionais .............................................................................. 23
Aula 6 ............................................................................................................................. 25
Exercícios ................................................................................................................... 25
Aula 7 ............................................................................................................................. 26
Seleção encadeada ...................................................................................................... 26
5.4. Instrução SWITCH ..................................................................................... 27
5.6. Operadores (Conectores) Lógicos .............................................................. 29
5.6.1. Operador && (E) .................................................................................... 29
5.6.2. Operador || (OU) ..................................................................................... 29
5.6.3. Operador ! (Não) .................................................................................... 29
Aula 8 ............................................................................................................................. 32
Aula 9 ............................................................................................................................. 33
Avaliação I.................................................................................................................. 33
6. Introdução ....................................................................................................... 33
6.1. Tipo de avaliação ........................................................................................ 33
6.2. Continuação dos exercícios ........................................................................ 33
Aula 10 ........................................................................................................................... 34
Algoritmos de Repetição (Laços – Loops) ................................................................. 34
7. Introdução ....................................................................................................... 34
7.1. WHILE (ENQUANTO) ............................................................................. 34
7.2. DO – WHILE (FAÇA ENQUANTO) ........................................................ 35
7.3. FOR (PARA) .............................................................................................. 36
7.4. Tipos de Variáveis ...................................................................................... 36
7.4.1. Variáveis Contadoras.............................................................................. 36
7.4.2. Variáveis Acumuladoras ........................................................................ 36
7.4.3. Lixo de Memória .................................................................................... 37
7.5. Modificações do Sinal de Atribuição ......................................................... 37
7.6. Loops Infinitos............................................................................................ 37
Aula 11 ........................................................................................................................... 38
Aula 12 ........................................................................................................................... 39
Aula 13 ........................................................................................................................... 40
Aula 14 ........................................................................................................................... 41
Aula 15 ........................................................................................................................... 42
Revisão Geral Para a Prova I ...................................................................................... 42
Aula 16 ........................................................................................................................... 43
Prova I ........................................................................................................................ 43
Aula 17 ........................................................................................................................... 44
Considerações sobre a prova ...................................................................................... 44
Aula 18 ........................................................................................................................... 45
Variáveis Homogêneas Unidimensionais (Vetores) ................................................... 45
8. Introdução ....................................................................................................... 45

8.1. O que são vetores? ...................................................................................... 45
8.2. Representação Gráfica ................................................................................ 45
8.3. Utilidade para Vetores ................................................................................ 45
8.4. Declarando Vetores .................................................................................... 45
8.5. Exemplo Prático ......................................................................................... 46
Aula 19 ........................................................................................................................... 48
Aula 20 ........................................................................................................................... 49
Aula 21 ........................................................................................................................... 50
Variáveis Homogêneas Multidimensionais (Matrizes) .............................................. 50
9. Introdução ....................................................................................................... 50
9.1. O que são Matrizes? ................................................................................... 50
9.2. Representação Gráfica ................................................................................ 50
9.3. Declarando Matrizes. .................................................................................. 50
9.4. Exemplo Prático ......................................................................................... 51
Aula 22 ........................................................................................................................... 53
Aula 23 ........................................................................................................................... 54
Aula 24 ........................................................................................................................... 55
Introdução a Programação Modular ........................................................................... 55
10. Introdução ................................................................................................... 55
10.1. Por que Utilizar Programação Modular? ................................................ 55
10.2. Como Implementar Programação Modular? .......................................... 55
10.2.1. Funções ................................................................................................... 55
10.2.2. Assinatura ............................................................................................... 55
10.2.3. Argumento .............................................................................................. 55
10.2.4. Parâmetro ................................................................................................ 55
10.3. Exemplo Prático ..................................................................................... 55
10.4. Escopo das Variáveis – Instanciamento de Variáveis ............................ 57
10.5. Exercícios Propostos .............................................................................. 58
Aula 25 ........................................................................................................................... 59
10.6. Passagem de Parâmetros por Valor e Referência ................................... 59

Introdução
A disciplina introduz o estudo da programação, destacando a construção de algoritmos.
Abrange os conceitos fundamentais da programação até o uso de estruturas básicas de
dados (vetores, matrizes e registros).

Aula 1
Apresentação da Disciplina
1. Considerações iniciais
1.1. Lógica e Lógica de Programação

Lógica de programação é a técnica de encadear pensamentos para atingir
determinado objetivo. Estes pensamentos podem ser descritos como uma seqüência de
instruções que devem ser seguidas para se cumprir uma determinada tarefa. Gerando ao
final o que chamamos de programa.
1.2. Problema
A definição mais simples para problema é uma situação que precisa ser resolvida
1.3. Algoritmo
Algoritmo é uma seqüência ordenada e finita de passos lógicos, bem definas e
eficazes para a solução de um problema em um tempo finito.
Reparem que algoritmo não está diretamente relacionado à informática. Uma receita de
bolo, por exemplo, seria um algoritmo que iria solucionar um problema específico do
cotidiano humano.
Reparem também que para um problema podemos ter diversos algoritmos, e que
muitas vezes, estes só funcionariam dependendo de fatores externos. Como fazer um
bolo de chocolate visto que faltou luz? A solução provavelmente será diferente da
solução convencional.
1.4. Programa
Um programa não mais é do que um algoritmo computacionalmente aplicável. Isto
é, serve para resolvermos problemas exclusivos do ambiente computacional.
Todo programa é um algoritmo, porém nem todo algoritmo é um programa.
1.5. Formas de se representar um Algoritmo

Existem várias formas de se representar um algoritmo. Uma delas é escrevê-lo
através da linguagem natural que usamos no dia-a-dia. Esta maneira, porém, podem
levar a muitas ambigüidades, passíveis de interpretações errôneas.
Outra forma de se representar os algoritmos são os fluxogramas convencionais, que
usam formas geométricas diferentes para as diversas ações. Este método é bastante
popular pela sua facilidade de compreensão, mas é um pouco limitado, preocupando-se
muito com detalhes de nível físico da implementação do algoritmo. Outros tipos de
fluxogramas mais modernos foram criados, mas não obtiveram a mesma popularidade.
Na medida que os algoritmos tornaram-se muito grandes e complexos, os fluxogramas
deixaram de ser utilizados para a representação da implementação, sendo direcionados
para a fase de projeto do software.
A terceira forma chama-se de pseudocódigo ou metalinguagem. Esta forma de
representação de um algoritmo assemelha-se muito à forma com que os programas são
escritos e consiste na descrição dos passos do algoritmo através de frases construídas
sob uma sintaxe rigorosamente definida. Assim, consegue-se uma descrição do

algoritmo livre de ambigüidades e com uma estrutura bastante flexível e completa, onde
todos os elementos estão representados.
No estudo da lógica de programação da nossa disciplina, será utilizada a terceira
forma de representação, utilizando a sintaxe da linguagem de programação C. Não
utilizaremos o padrão de português estruturado para evitar que nossos algoritmos
precisem ser reescritos (faça em português, e depois refaça na sintaxe correta da
linguagem).
1.6. Regras para a Criação de Algoritmos

A criação de algoritmos computacionais obedece ao princípio da informática.
Sendo assim, sempre devemos pensar que nossas soluções devem passar por três
fases distintas:
Entrada Processamento Saída
Onde:
Entrada: São os dados que devem ser informados (pelo usuário, ou não) para que o
programa possa ser executado.
Processamento: São os procedimentos que devem ser empregados para solucionar o
problema. Neste podemos incluir operações matemáticas, comparações, repetições, etc.
Saída: É o resultado final do algoritmo que deve ser entregue a algum lugar ou alguém.
É importante ressaltar que:

A ordem das instruções devem ser levadas em consideração.
Não existe processamento sem a entrada de dados.
A saída de dados deve ser apresentada.
O número de instruções deve ser sempre finito.
Exemplo
Imagine o seguinte problema: calcular a média final dos alunos da 3ª Série. Os
alunos realizarão quatro provas: P1, P2, P3 e P4.
Onde:
P1 + P2 + P3 + P4
Média Final =
4
A entrada de dados serão as quatro notas.
O processamento será o cálculo da média propriamente dita.
A saída de dados será a exibição dessa média.
1.7. Como proceder na construção de algoritmos?
1.7.1. Leia com atenção o enunciado do problema

Nessa primeira etapa devemos compreender perfeitamente o que precisamos
fazer. A grande maioria dos problemas encontrados nos programas atuais ocorre
por falhas na interpretação inicial do problema.
1.7.2. Obtenha os dados de entrada

Durante a leitura do problema, podemos descobrir quais são os dados que
precisamos solicitar para a execução do algoritmo.

1.7.3. Obtenha os dados de saída
Da mesma forma que na entrada de dados, os dados de saída (qual a resposta que
preciso informar) também pode ser descoberta lendo atentamente a definição do
problema.
1.7.4. Determinar o que deve ser feito para transformar as

entradas determinadas nas saídas especificadas
Nesta fase é que teremos a construção do algoritmo propriamente dito, pois, a
partir de alguns requisitos especificados, devemos determinar qual seqüência de
ações é capaz de transformar um conjunto definido de dados nas informações de
resultado.
1.7.5. Testar o algoritmo

Nesta fase devemos verificar se o algoritmo realmente resolve o problema
proposto, mesmo com variações nos dados de entrada. Essa é uma das principais
fases do projeto, afinal, a premissa que devemos ter em relação a um software
lançado no mercado é a de que este funciona. Chamamos esta etapa de teste de
mesa.
Vale ressaltar, que por mais exaustiva que seja a bateria de testes. Um programa
nunca estará 100% imune a erros. Nessa etapa tentamos chegar o mais próximo
possível deste índice.
1.8. Exercícios propostos
1. Especifique as ações necessárias para mover três disco de uma Torre de Hanói, que
consiste de três hastes (a - b - c), uma das quais serve de suporte 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 disco para outra haste.
a b c
2. Construa um algoritmo que informe os passos necessários para a trocar o pneu de
um carro. Tendo como situação inicial que o carro estava em movimento numa
estrada, que há acostamento e espaço suficiente para a troca.

2. Variáveis e Constantes de memória (RAM)
2.1. Memória
Memória é um dispositivo utilizado para guardar de forma temporária ou não algum
tipo de informação.
Quando um programa é executado (tornando-se o que chamamos de processo), todo o
seu conteúdo é posto na memória RAM (Random Access Memory) do computador.
Sendo que é somente nela que o mesmo é executado.
2.2. Como um programa é tratado na memória?

Todo o programa que é posto da memória RAM do computador é dividido em três áreas
Área de Dados
Área de Código
Pilha
Onde:
Área de Dados: É o local destinado para o armazenamento dos dados vindos do
usuário, cálculos, saídas. Enfim, é o espaço que o algoritmo tem para trabalhar.
Área de Código: É o local onde está o algoritmo propriamente dito.
Pilha: É quem garante a continuidade do programa. Se o programam efetua “saltos”
dentro do código, é a pilha que mantém a informação de onde o código estava antes do
salto consequentemente garantindo um retorno correto ao final do salto. Pilhas utilizam
uma estrutura de dados manipulada pelo que chamamos de FIFO (First Input First
Output).
2.3. Variáveis
Variáveis são espaços reservados (alocados) na memória RAM do computador, que
devem possuir um nome e um tipo de dado, sendo que seu conteúdo pode sofrer
alteração durante a execução do programa.
Em outras palavras, variáveis são as informações que podemos utilizar na área de dados
de um programa. Por exemplo, o Nome de um cliente, as Notas de um aluno, a
Temperatura atual. Mas note que todos estes dados podem mudar a qualquer momento.
2.4. Constantes
Variáveis são espaços reservados (alocados) na memória RAM do computador, que
devem possuir um nome e um tipo de dado, sendo que seu conteúdo NÃO pode sofrer
alteração durante a execução do programa.
Repare que a diferença entre uma variável e uma constante na sua definição é sutil,
porém na prática essa diferença é muito relevante. O valor que for definido na criação
(declaração) de uma constante a acompanha durante todo o ciclo de vida do processo.
2.5. Regras para formação de Identificadores

Para a criação de um identificador (nome de uma variável ou constante, por exemplo)
devemos tomar cuidado com uma série de fatores. São eles:
O nome de um identificador não pode ser iniciado por número.
O nome de um identificador não pode conter espaços ou qualquer caracter
especial, exceto o underline “_”.

O nome de um identificador não pode ser igual ao de qualquer palavra reservada
da linguagem de programação.
Procure utilizar nomes curtos, e que possuam algum significado associado ao
identificador.
2.6. Tipos de Dados

Dados, são as informações em sua forma mais bruta. Sendo que estas informações
podem ser classificadas em alguns grupos distintos
Numéricos: Conjunto formado pelos números (inteiros, reais, etc).
Alfanuméricos: Conjunto formado por letras e números (palavras).
Lógicos: Representam apenas dois valores/estados. Verdadeiro ou Falso.
Vale ressaltar que a linguagem C (não C++) não possui um tipo de dado que represente
valores lógicos.
2.7. Principais tipos de dados utilizados na disciplina

Int (inteiro): Números inteiros entre -32768 e 32767
Float (ponto flutuante): Números reais entre 3,4E-38 e 3,4E+38
Char (caracter): Tipo alfanumérico que pode variar entre 1 e 255 caracteres,
este tipo pode também ser referido por string.
Void: Representa a não existência de um tipo.
Vale ressaltar que estes não são os únicos tipos de dados existentes na linguagem C,
mas sim os que utilizaremos durante o curso de lógica de programação.
2.8. Exercícios Propostos

1. Quais dos identificadores abaixo são considerados INVÁLIDOS? Justifique sua
resposta.
a) Contas_a_pagar
b) Salário_Familia
c) 1Bimestre
d) Nota1
e) Endereço
f) #DDD
g) Telefone Residencial
2. Defina o melhor tipo de dado para cada expressão abaixo. Considerando apenas int,
float e char.
a) 23.56
b) “minha casa é azul”
c) 45
d) “123B56”
e) -345
f) 40456
g) -34.6

Aula 2
Começando a programar na Linguagem C
3. Linguagens de programação
Linguagem de programação é uma classe de software (do mesmo jeito que editores de
texto, planilhas eletrônicas, etc.) onde todos os seus representantes têm por
característica principal a capacidade de desenvolver novos softwares. Sendo que essa
classe de software é dividida em dois grandes grupos. Linguagens de alto e baixo nível.
3.1. Linguagens de Baixo Nível

São as linguagens que mais se aproximam do idioma da máquina. Possuem uma maior
complexidade de compreensão, porém seu desempenho é significativamente melhor do
que as linguagens de alto nível.
Exemplos de linguagens de baixo nível: Assembly, Fortran, Algol e C.
3.2. Linguagens de Alto Nível

São as linguagens que mais se aproximam do idioma humano. Possuem uma
complexidade de aprendizado inferior as linguagens de baixo nível, porém possuem
desempenho também inferior a estas.
Como o “idioma humano” é vasto, vale ressaltar que a grande maioria das linguagens de
programação encontram-se no idioma Inglês.
Exemplos de linguagens de alto nível: Cobol, Clipper, Basic, Visual Basic, Pascal e
Delphi.
3.3. Compilador
Compilador é o nome do software responsável pela tradução de um código alto nível
para baixo nível (para que o processador possa executar suas instruções) gerando ao
final o que chamamos de arquivo executável. Sendo que a velocidade de processamento
de um programa está diretamente relacionado a qualidade deste compilador.
3.4. Estrutura padrão de um algoritmo (C)

Para programarmos na linguagem C, devemos nos preocupar primeiro com a sua sintaxe
básica. Abaixo estão explicitadas algumas das principais características da linguagem.
Case Sensitive: O nome de um identificador, bem como de instruções devem
ser escritos da mesmo forma que foram criados, de modo que letras maiúsculas e
minúsculas fazem diferença.
Utilização de bibliotecas: Para utilizarmos alguma instrução já existente na
linguagem, devemos identificar em qual biblioteca essa instrução se encontra
logo no inicio do código através da instrução “include”.
Utilização de um bloco principal: Todo o programa desenvolvido em C, deve
possuir uma função principal definida com o nome “main”.
Definição de inicio e fim de bloco: Sempre que precisarmos definir inicio e fim
de um bloco de instruções, utilizaremos os caracteres {}.
Obs: Como utilizaremos o compilador DEV-C++ durante as aulas, algumas
includes podem ter nomes diferentes das tradicionais includes do C.

Exemplo de um programa
#include <stdio.h>
void main()
{
int valor1, valor2;
float soma;
valor1 = 23000;
valor2 = 15500;
soma = valor1 + valor2;
}
Explicando o código acima

#include <stdio.h> Esta linha define que poderemos utilizar no nosso código
fonte instruções de I/O (Entrada e Saída de dados).
void main() Define onde que o nosso programava vai começar a
execução
{ Inicio do bloco de instruções
int valor1, valor2 Cria na área de dados (declara) duas variáveis de tipo
inteiro com nomes valor1 e valor2.
float soma; Cria na área de dados (declara) uma variável de tipo
ponto flutuante com nome soma
valor1 = 23000; Atribui o valor 23000 para a variável valor1
valor2 = 15500; Atribui o valor 15500 para a variável valor2
soma = valor1 + valor2; Soma o conteúdo das duas variáveis e joga a resposta do
cálculo na variável soma.
} Encerra o bloco de intruções
3.5. Endentação
Repare que o código acima possui alguns espaços entre os caracteres { e } que servem
para facilitar a visualização do código na busca de possíveis erros. Esta técnica chama-
se endentação de código. Sendo vital no desenvolvimento de um programa.
Na grande maioria das linguagens a endentação tem uma importância meramente
estética, porém existem linguagens que definem inicio e fim de bloco por ela. Python
seria um bom exemplo disso.

3.6. Operadores aritméticos

Dentro da linguagem C, utilizaremos os seguintes operadores aritméticos:
Operador Nome Exemplo Resposta
+ Adição X=5+2 7
- Subtração X=5–2 3
* Multiplicação X=5*2 10
/ Divisão inteira X = 5/2 2
/ Divisão real X = 5.0/2.0 2.5
% Resto de uma divisão inteira X=5%2 1
pow Potenciação* X = pow(5,2) 25
sqrt Raiz quadrada* X = sqrt(25) 5
* Para que as funções “pow” e “sqrt” possam funcionar corretamente, devemos

adicionar a biblioteca “math.h” nas includes de seu código.
3.7. Regras de precedência de operadores

As regras de precedência matemática entre os operadores aritméticos é respeitada pelo
compilador C. Sendo assim, a multiplicação e divisão são efetuadas antes da adição e
subtração, por exemplo. Se você quiser que a regra de precedência seja modificada, é
permitida a utilização de parênteses. De modo que tudo o que estiver dentro destes
parênteses serão calculados primeiro.

1. Faça um algoritmo que calcule a média entre dois valores inteiros (5 e 25).
2. Faça um algoritmo que calcule a área de um quadrado de lado L= 10.
3. Faça um algoritmo que calcule a hipotenusa de um triângulo retângulo de catetos

b=3 e c = 4. ( h b2 c2 )
4. Faça um algoritmo que efetue as seguintes operações:

a) A vale 10
b) B vale o dobro de A
c) C vale a raiz quadrada do dobro de A
d) D vale a metade da raiz quadrada do dobro de A
e) E vale o cubo da metade da raiz quadrada do dobro de A
f) F vale a terça parte do cubo da metade da raiz quadrada do dobro de A.

Aula 3
3.9. Utilizando instruções de I/O
Até o momento, nossos algoritmos apesar de funcionarem, não estão respeitando
corretamente o principio da informática (aula 1) que é o da Entrada, Processamento e
Saída de dados. Já que:
Nossa entrada de dados é sempre fixa
Não estamos exibindo o resultado de nossos cálculos para o usuário do
programa.
Para solucionar este problema, a linguagem C possui três instruções para a
leitura/escrita de dados, scanf, gets e printf. Onde:
scanf: Utilizado para a leitura de valores numéricos, sendo que sempre devemos
utilizar o operador “&” antes da variável de leitura.
gets: Utilizado para leitura de valores alfanuméricos
printf: Utilizado para a escrita de valores tanto numéricos quanto
alfanuméricos.
Exemplo de utilização
#include <stdio.h>
void main()
{
int v1, v2;
float media;
char nome[30];
gets(nome);
scanf("%d", &v1);
scanf("%d", &v2);
media = (v1 + v2)/2.0;
printf ("A sua media é: %f", media);

}
Repare a maneira como foi feita a leitura das variáveis nome, v1 e v2:
Nome como é um char, foi lida utilizando a função gets.
v1 e v2 por serem numéricas, precisaram ser lidas utilizando o scanf, sendo que
“%d” é um atributo da função que avisa o compilador que será lido (no caso da
printf, escrito) um valor de tipo de dado inteiro.
A leitura da linha onde encontra-se o printf seria da seguinte forma: Escreva na
tela a frase “A sua média é: juntamente com um valor de ponto flutuante”, sendo
que esse valor foi passado para a função logo em seguida separado por uma
vírgula.
Alguns atributos importantes que podem ser utilizado nas funções scanf e printf:
Atributo Utilização Exemplo
%d Leitura/escrita de dados numéricos inteiros scanf(“%d”, &idade);
%f Leitura/escrita de dados numéricos reais printf(“%f”,salario);
%s Escrita de dados do tipo char (strings) printf(“%s”, nome);

Dentro de uma instrução printf, podemos fazer a escrita de mais valores, compondo uma
sentença completa.
Exemplo:
printf (“%s, Os valores %d e %d formam a média: %f”, nome, v1, v2, media);
Podemos também utilizar a função printf para exibir mensagens para o usuário. Por
exemplo, no caso anterior, seria interessante exibir uma mensagem ao usuário pedindo
para que ele informe o seu nome e dois valores inteiros.
O código ficaria da seguinte maneira:
#include <stdio.h>
void main()
{
int v1, v2;
float media;
char nome[30];
printf ("Digite o seu nome: ");

gets(nome);
printf ("Digite o primeiro valor inteiro: ");
scanf("%d", &v1);
printf ("Digite o segundo valor inteiro: ");
scanf("%d", &v2);
media = (v1 + v2)/2.0;
printf ("%s, Os valores %d e %d formam a media: %f", nome, v1, v2, media);
}

1. Refaça as questões 1, 2 e 3 da lista anterior, utilizando agora os comandos para
entrada e saída de dados.
2. Faça um algoritmo que leia três valores reais (ponto flutuante) e calcule a sua média
ponderada, com os respectivos pesos 2, 3 e 4 para os valores.
3. Faça um algoritmo que leia um valor inteiro e um valor real. Multiplique estes
valores e exiba o resultado.
4. Faça um algoritmo que leia 4 valores reais (x1, y1, x2, y2) equivalentes a dois pares
ordenados. Calcule e exiba a distância entre estes dois pontos de acordo com a
fórmula abaixo:
d ( x2 x1 ) 2 ( y2 y1 ) 2
5. Faça um algoritmo que leia três valores reais e calcule x’ e x” de acordo com a
fórmula abaixo
b b2 4 * a * c
x' , x"
2*a

6. Faça um algoritmo que leia um valor inteiro equivalente a um determinado valor em
segundos. Retorne quantas horas, minutos e segundos são compostos por este valor.
Por exemplo o valor 3670 (segundos) formaria 1 hora, 1 minuto e 10 segundos.
7. Faça um algoritmo que leia dois valores inteiros. Logo após troque os valores entre
estas variáveis. Ou seja, o conteúdo da variável 1 passará para a variável 2 e vice e
versa.

Aula 4
Introdução ao DEV-C++
4. Sobre o software
4.1. O que é DEV-C++?

DEV-C++ é o nome de um dos mais famosos compiladores C para a plataforma
Windows, sendo que este é um freeware que pode ser baixado dos mais diversos
lugares. Alguns links serão escritos no apêndice deste manual.
4.2. Versão do DEV-C++

Utilizaremos durante as aulas a versão 4.9.9.2 do DEV-C++
4.3. Interface do Software

Após uma instalação simples do programa o ambiente de desenvolvimento deve ser
como o mostrado abaixo:
Onde:
No canto esquerdo temos o navegador de classes/projetos que será utilizado para
podermos alternar entre arquivos.
Na área superior encontram-se os principais atalhos do compilador
Na parte inferior temos uma caixa de mensagens que o compilador irá exibir
conforme a necessidade.

Criando um novo projeto
Para criarmos um novo projeto devemos acessar o menu Arquivo/Novo/Projeto...
Escolha a opção Console Application, certificando-se que a opção “Projeto C” esteja

marcada.
Você pode definir um nome para seu projeto nesta mesma janela.
Ao clicar em OK, o compilador irá solicitar que você salve seu projeto. Procure salvar
um projeto por pasta para evitar um acumulo de arquivos, de modo que seja fácil a
seleção do documento certo.

Logo após a criação do projeto. Você estará apto para começar a programar.
Repare que a interface do código é muito similar ao que já estamos trabalhando, de
modo que apenas precisamos modificar (apagar) algumas instruções e nossa aplicação
estará igual ao de nosso caderno.
Repare que existe uma linha obrigatória no final do código fonte:

system (“pause”);
Onde:
system(“pause”): Fará com que o programa após sua conclusão seja fechado somente
após o pressionamento de alguma tecla. A não existência desta linha de instrução
fecharia o programa sem que o usuário tenha tempo de visualizar as respostas. Podemos
utilizar qualquer instrução DOS na função system.
4.4. Compilando um Projeto

Após a escrita do algoritmo, finalmente é a hora de testar o funcionamento do mesmo.
Para isso, devemos compilar nosso projeto.
Existem três atalhos importantes que devemos saber nesse momento.
Pressionar as teclas CTRL + F9: Compila o código, porém não o executa.
Pressionar as teclas CTRL + F10: Executa um código compilado.
Pressionar a tecla F9: Compila e executa o código.
É importante ressaltar que quando um projeto for compilado, ele deverá ser salvo
novamente.

Abaixo temos uma imagem que representa o resumo do compilador:
Repare que neste caso o compilador não encontrou nenhum erro durante a tradução do
código fonte.
Vejamos abaixo uma situação onde existam erros de sintaxe.
No lugar do resumo de compilação, o código teve uma linha destacada e na parte

inferior do programa estão sendo exibidos alertas do compilador. Neste caso a
informação é de que o programa não conseguiu compilar a linha 10, devido a falta de
um “;” na linha 9.

4.5. Tipos de Erros

Durante toda o processo de desenvolvimento de software, encontraremos apenas dois
tipos de erros em nossos programas. São eles:
Erros de Sintaxe: Ocorrem durante a fase de projeto do código, caracterizados
por falhas na digitação (eu escrevo errado). São facilmente identificados, pois
são acusados pelo compilador. Como por exemplo escrever “mai” no lugar de
“main”.
Erros de Lógica: Ocorrem em tempo de execução, caracterizados por falhas na
concepção do código (eu penso errado). São muito mais complexos de serem
encontrados, já que o programa é executado normalmente, sendo que este apenas
devolve um valor errado de resposta. Este tipo de erro só pode ser encontrado
com testes de mesa.
4.6. Exercício Proposto

1. Passe todos os algoritmos feitos na listagem anterior para o DEV-C++, anotando
possíveis erros de sintaxe e perguntando para seu professor o que estes significam.

Aula 5
Algoritmos Condicionais
5. Introdução
Até o momento, todos os algoritmos que estamos fazendo podem ser considerados
Algoritmos Seqüenciais, isto é, executam todas as suas linhas de instrução sem que
hajam desvios nem repetições no código fonte. Em um ambiente prático, este tipo de
situação não ocorre, já que durante um programa diversas situações devem ser testadas
para que seu resultado final seja satisfatório.
Por exemplo, se formos fazer um programa para cálculo de peso ideal para um
indivíduo, a fórmula para homens e mulheres é diferente. Sendo assim, em algum
momento do programa deve-se descobrir o sexo da pessoa e caso seja alguém do sexo
masculino, faça a fórmula X, caso contrário, a fórmula Y será executada.
Para podermos trabalhar com algoritmos condicionais podemos utilizar dois tipos de
instruções IF (SE) e SWITCH (CASO, não é tradução literal):
5.1. Instrução IF (SE)

Esta instrução avalia uma determinada condição lógica, e dependendo da resposta que
esta condição retornar, será feito um bloco de algoritmo ou não.
Sintaxe:
if (condição lógica)
{
<Bloco de algoritmo que será executado caso a condição lógica seja verdadeira>;
}
<Bloco de algoritmo que será executado independentemente da resposta da condição
lógica>;
Dentro da instrução if, ainda podemos utilizar uma segunda instrução (else - senão) que
também avalia a condição lógica testada, porém somente sendo executado se esta
condição for falsa.
Sintaxe:
if (condição lógica)
{
<Bloco de algoritmo que será executado caso a condição lógica seja verdadeira>;
}
else
{
<Bloco de algoritmo que será executado caso a condição lógica seja falsa>;
}
Para melhor compreensão, faremos agora um exemplo prático da utilização deste tipo
de instrução. Façamos um algoritmo que leia o nome e as duas notas de um aluno,
retornando a sua média e uma mensagem “Aprovado” ou “Reprovado” dependendo da
sua média. A média mínima para aprovação será 6.

#include <stdio.h>
void main()
{
float n1, n2, media;
char nome[25];
printf("Digite o seu nome: ");

gets(nome);
printf("Digite sua primeira nota: ");
scanf("%f", &n1);
printf("Digite sua segunda nota: ");
scanf("%f", &n2);
media = (n1 + n2)/ 2.0;

printf ("%f \n", media);
if (media >= 6)
{
printf ("Parabens! Voce esta APROVADO \n");
}
else
{
printf ("Infelizmente voce esta REPROVADO \n");
}
system("pause");
}
O trecho em destaque no código é o que diferencia um algoritmo condicional de um

puramente seqüencial. Repare que apenas uma das duas mensagens será exibida na tela,
sendo que tudo depende do retorno do teste “media >= 6”(média ser maior ou igual a 6).
5.2. Operadores Relacionais

Para que possamos fazer perguntas lógicas para o processador, devemos sempre utilizar
um dos operadores abaixo demonstrados.
Operador Significado
> Maior do que
< Menor do que
>= Maior ou igual a
<= Menor ou igual a
== Igual a
!= Diferente de


1. Faça um algoritmo que leia um valor real qualquer e o classifique como POSITIVO
ou NEGATIVO. Obs: Trate o número ZERO como positivo.
2. Faça um algoritmo que leia um valor inteiro e informe se este valor é maior do que
10 ou não.
3. Faça um algoritmo que leia dois valores reais e informe se estes valores são iguais
ou diferentes.
4. Faça um algoritmo que leia um valor inteiro e retorne se este valor é PAR ou
ÍMPAR.
5. Faça um algoritmo que leia dois valores reais e exiba ao final qual dos dois é o
maior.
6. Faça um programa que leia o Nome, Valor Hora e Total de Horas Trabalhadas de
um funcionário. Calcule e exiba:
a) O salário bruto
b) O valor de Vale Transporte (6% do Salário Bruto)
c) O desconto de Imposto de Renda (11% do Salário Bruto para salários superiores
a R$ 1440,00)
d) O salário líquido.
7. Faça um algoritmo que leia dois valores inteiros equivalentes a hora inicial e final de
um jogo. Retorne o tempo de duração deste jogo sabendo que o jogo pode começar
em um dia e terminar em outro, e que o tempo máximo de jogo é 24 horas.

Aula 6
Exercícios
Aula destinada a continuação e implementação dos exercícios sobre algoritmos
condicionais.

Aula 7
Seleção encadeada
É muito comum que dentro de um algoritmo tenhamos vários testes que tenham que ser
feitos a uma mesma variável ou situação. Para este tipo de situação podemos utilizar o
encadeamento (aninhamento) de instruções if. Por exemplo, vamos modificar o
exercício número um da lista anterior para que agora ele considere o valor 0 (zero)
como nulo.
#include <stdio.h>
void main()
{
float valor;
printf("Digite um valor: ");

scanf("%f", &valor);
if (valor > 0)
{
printf("O valor é positivo! \n");
}
else
{
if (valor < 0)
{
printf("O valor é Negativo! \n");
}
else
{
printf("O valor é nulo! \n");
}
}
system("pause");
}
Repare que o segundo teste só será feito caso o primeiro falhe. Este tipo de abordagem é
interessante para evitar que uma grande quantidade de testes similares sejam feitas
quando apenas um deles pode ser executado.

5.4. Instrução SWITCH

Utilizar uma seqüência encadeada de testes lógicos apesar de interessante, em algumas
situações pode tornar o código relativamente complexo. Quando possuímos uma lista de
valores para avaliar-mos, por exemplo.
Quando nos deparamos com este tipo de situação existe uma instrução que se mostra
mais otimizada e organizada para a manipulação dos dados. Essa instrução chama-se
switch.
Exemplo:
#include <stdio.h>
void main()
{
int valor;
printf("Digite um valor: ");

scanf("%d", &valor);
switch (valor)
{
case 1:
printf ("Foi digitado o valor 1 \n");
break;
case 2:
break;
case 3:
break;
default:
printf("Foi digitado um valor diferente de 1, 2 ou 3 \n");
}
system("pause");
}
A instrução switch através de instruções case avalia o conteúdo da variável “valor”, de

modo que a instrução “default” é executada se todos os testes falharem.
Percebam que dentro de cada case foi utilizado uma instrução “break” que fará com que
o switch seja interrompido no momento que encontrar a associação correta para a
variável “valor”.
Dentro de cada case não é necessário definir o bloco entre chaves.

1. Faça um algoritmo que recebe um número inteiro, escreva o mês correspondente a
este número ou a mensagem “mês inválido”

2. Faça um algoritmo que recebe dois valores reais juntamente com uma variável
controladora de tipo inteiro.
a) Caso a variável controladora seja 1, some os valores digitados.
b) Caso a variável controladora seja 2, multiplique os valores digitados.
c) Caso a variável controladora seja 3, encontre o maior valor.
d) Caso a variável controladora seja qualquer outro valor, calcule a média entre os
valores.
3. Faça um algoritmo que simule o caixa de um Fast-Food. Serão digitados o código de

um produto, juntamente com a quantidade desejada deste produto. Seu programa
deve retornar o nome do produto juntamente com o valor final a ser pago.
Código Produto Valor Unitário

1 Sanduíche de Presunto R$ 2,30
2 Suco de Tamarindo R$ 1,50
3 Pastel de Vento R$ 1,30
4 Pão com margarina R$ 0,70

5.6. Operadores (Conectores) Lógicos

Além do que já foi trabalhado durante o curso, existe a possibilidade de que uma
expressão lógica faça mais de uma pergunta ao mesmo tempo. De modo que essas
perguntas tem de estar relacionadas de alguma forma. Imagine que exista a necessidade
de se fazer um filtro em um programa de modo que sejam tratados de forma diferente
pessoas do sexo feminino menores de idade, maiores de idade, pessoas do sexo
masculino maiores de idade e menores de idade.
Se formos fazer um teste para cada possibilidade, o código seria gigantesco. Utilizando
os operadores lógicos, poderíamos fazer perguntas agrupadas (se for mulher E menor de
idade, se for homem E maior de idade, etc.).
Durante o curso iremos trabalhar com três operadores lógicos. São eles:
5.6.1. Operador && (E)

Também conhecido como multiplicação lógica
Retorna como resposta “Verdadeiro” se e somente se as duas expressões lógicas
por ele conectadas forem verdadeiras.
Tabela verdade
&& V F
V V F
F F F
5.6.2. Operador || (OU)

Também conhecido como adição lógica
Retorna como resposta “Falso” se e somente se as duas expressões lógicas por
ele conectadas forem falsas.
Tabela verdade
|| V F
V V V
F V F
5.6.3. Operador ! (Não)

Também conhecido como inversor lógico
Retorna o valor oposto a uma expressão lógica
Tabela verdade
! V F
F V
Exemplos
a) (25 > 10 && 23 % 2 == 1)? Resposta: VERDADEIRO
b) (25 != 50/2 || 12 > 20)? Resposta: FALSO
c) (!(2 + 2 = 4)) ? Resposta: FALSO
d) (40 > 30 && 25 < 12 || 12 % 2 ==0)? Resposta:
e) (!((25 > 10 && 23 % 2 == 1)))? Resposta:

Exemplo Prático
Fazer um programa que leia as duas notas de um aluno juntamente com sua
freqüência. Informe se o aluno está aprovado ou reprovado sabendo que a média
mínima de aprovação é 6 e que a freqüência mínima de aprovação é 75.
#include <stdio.h>
void main()
{
float n1, n2, freq, media;
printf("Digite sua primeira nota: ");

scanf("%f", &n1);
printf("Digite sua segunda nota: ");
scanf("%f", &n2);
printf("Digite sua freqüência: ");
scanf("%f", &freq);
media = (n1 + n2)/ 2.0;

if (media >= 6 && freq >= 75)
{
printf ("Parabens! Voce esta APROVADO \n");
}
else
{
printf ("Infelizmente voce esta REPROVADO \n");
}
system("pause");
}
Tente fazer o código acima utilizando operador lógico OU agora.


1. Faça um algoritmo que lê um valor inteiro e retorna se este é um valor Par Positivo,
Par Negativo, Ímpar Positivo, Ímpar Negativo ou Nulo.
2. Faça um algoritmo que leia três valores reais e os exiba de forma crescente.
3. Faça um algoritmo que leia três valores reais e exiba ao final o maior valor
4. Faça um algoritmo que leia três valores reais e calcule x’ e x” de acordo com a
fórmula abaixo. Obs.: Seu programa deve prever os erros de raiz negativa e divisão
por zero.
b b2 4 * a * c
x' , x"
2*a
5. Faça um programa que dada a idade de um nadador classifica-o em uma das

seguintes categorias:
Infantil = 8-10 anos
Juvenil = 11-17 anos
Adulto = maiores de 18 anos

Aula 8
Aula destinada a continuação e implementação dos exercícios propostos na lista
anterior, bem como novos exercícios disponibilizados pelo professor.
Continuação dos exercícios:
6. A Secretaria de Meio Ambiente, que controla o índice de poluição, mantém 3 grupos

de indústrias que são altamente poluentes do meio ambiente. O índice de poluição
aceitável varia de 0,05 até 0,29. Se o índice sobe para 0,3 as indústrias do 1º grupo
são intimadas a suspenderem suas atividades, se o índice crescer para 0,4 as
industrias do 1º e 2º grupo são intimadas a suspenderem suas atividades, se o índice
atingir 0,5 todos os grupos devem ser notificados a paralisarem suas atividades. Faça
um programa que leia o índice de poluição medido e emita a notificação adequada
aos diferentes grupos de empresas.
7. Desenvolva um algoritmo que efetue a leitura de três valores para os lados de um

triângulo, considerando lados como: A, B e C. O algoritmo deverá verificar se os
lados fornecidos forma realmente um triângulo (cada lado é menor que a soma dos
outros dois lados). Se for esta condição verdadeira, deverá ser indicado qual tipo de
triângulo foi formado: isósceles (dois lados iguais e um diferente), escaleno (todos
os lados diferentes) ou eqüilátero (todos os lados são iguais).
Faça um algoritmo que leia o dia e o mês de nascimento de uma pessoa. Ao final do
algoritmo retorne o seu signo de acordo com a tabela abaixo:
Nascidos entre: Signo:

20/03 a 20/04 Áries
21/04 a 20/05 Touro
21/05 a 20/06 Gêmeos
21/06 a 21/07 Câncer
22/07 a 22/08 Leão
23/08 a 22/09 Virgem
23/09 a 22/10 Libra
23/10 a 21/11 Escorpião
22/11 a 21/12 Sagitário
22/12 a 20/01 Capricórnio
21/01 a 18/02 Aquário
19/02 a 19/03 Peixes

Aula 9
Avaliação I
6. Introdução
Aula destinada a apresentação do primeiro trabalho a ser desenvolvido na disciplina de
lógica de programação.
6.1. Tipo de avaliação

Cabe ao professor decidir que tipo de avaliação será proposta, podendo esta ser um
teste, trabalho para se entregar no mesmo dia ou um trabalho para ser entregue
posteriormente.
6.2. Continuação dos exercícios

No caso da avaliação ser um trabalho a ser entregue posteriormente, utilize essa aula
para dar continuidade nos exercícios.

Aula 10
Algoritmos de Repetição (Laços – Loops)
7. Introdução
Como visto anteriormente, dentro de um algoritmo existem vários tipos de estruturas
que podem ser utilizadas. Até o momento estudamos estruturas seqüenciais e
condicionais.
Dentro de nossos algoritmos vai ser comum encontrarmos trechos de código que
precisam ser executados várias vezes em seqüência (para validações, por exemplo). Para
este tipo de problema, ao invés de repetirmos seguidamente o código fonte, podemos
utilizar instruções de repetição que fazem justamente o papel de re-executar um
determinado bloco de algoritmo.
As instruções que permitem repetição de código são três:
7.1. WHILE (ENQUANTO)

Laço de repetição que executa um determinado bloco de instruções enquanto sua
condição lógica for verdadeira.
Sempre testa sua condição lógica antes de executar.
Após a execução do código, retorna para a condição e repete o teste.
Sintaxe:
while (condição lógica)
{
<instruções que serão executadas enquanto a condição for verdadeira>;
}

Exemplo:
#include <stdio.h>
void main()
{
int valor, soma;
valor = 5;
soma = 0;
while (valor <= 8)
{
soma = soma + valor;
valor = valor + 1;
}
printf("%d\n", soma);
system("PAUSE");
}
Este algoritmo irá executar as instruções “soma = soma + valor;” e “valor = valor + 1;”
enquanto o conteúdo da variável valor for menor ou igual a 8. Sendo que quando esta
condição for falsa o programa irá exibir essa soma na tela e encerrar.
7.2. DO – WHILE (FAÇA ENQUANTO)

Possui comportamento similar ao while.
Laço de repetição que executa um determinado bloco de instruções enquanto sua
condição lógica for verdadeira.
Sempre testa sua condição lógica depois de executar o bloco de instruções.
Executa pelo menos uma vez as instruções de seu bloco.
Sintaxe:
do
{
<instruções que serão executadas>
} while (condição lógica);
Exemplo:
#include <stdio.h>
void main()
{
int valor, soma;
valor = 5;
soma = 0;
do
{
valor = valor + 1;
} while (valor<=8);
system("PAUSE");
}
Repare que este código retorna o mesmo valor que o exemplo anterior, porém o teste é
feito apenas no final da execução da primeira volta do laço. Este tipo de abordagem é

muito comum quando utilizamos menus, onde as opções devem ser exibidas na tela
enquanto não for feita uma escolha válida.
7.3. FOR (PARA)

Laço de repetição contado.
Executa enquanto sua condição for verdadeira.
O controle de voltas do laço é feito pelo próprio laço.
Esta instrução de repetição é muito comum de ser utilizada quando sabemos exatamente
o número de voltas que nosso bloco de instruções irá fazer.
Sintaxe:
for (variável = valor inicia; condição de execução; valor de incremento para a variável)
{
<instruções que serão repetidas>;
}
Exemplo:
#include <stdio.h>
void main()
{
int valor, soma;
valor = 5;
soma = 0;
for (valor = 5; valor<=8; valor = valor +1)
{
}
system("PAUSE");
}
Utilizando este tipo de abordagem, reparem que não foi necessário incrementar a
variável valor dentro do bloco do for.
7.4. Tipos de Variáveis

Implementado laços de repetição em nossos códigos, devemos reparar que algumas
variáveis possuem um comportamento diferente do que estamos acostumados, onde elas
mesmas servem de base para o seu próximo valor.
7.4.1. Variáveis Contadoras

Tipo de variável que tem por comportamento principal sofrer alteração nos seus dados
de maneira constante. Nos exemplos anteriores a variável “valor” possui um
comportamento de contadora.
7.4.2. Variáveis Acumuladoras

Tipo de variável que tem por comportamento principal sofrer alteração nos seus dados
de maneira variável. Nos exemplos anteriores a variável “soma” possui um
comportamento de acumuladora.

7.4.3. Lixo de Memória
Na grande maioria das linguagens de programação, quando declaramos uma variável
esta possui um valor aleatório inicial chamado lixo de memória, de modo que se
mantermos este valor na variável, teremos um programa que retornará valores
incorretos. Para eliminar o problema do lixo de memória, devemos explicitamente dar
um valor inicial para as variáveis.
Todas as variáveis consideradas contadoras ou acumuladoras devem ser
inicializadas pelo programador.
7.5. Modificações do Sinal de Atribuição

O símbolo de atribuição “=” dentro da linguagem C pode sofrer algumas
transformações que visam diminuir o número de caracteres digitados dentro do código.
Sendo amplamente utilizados na manipulação de contadores e acumuladores.
Símbolo Exemplo Similar

+= A += 3; A = A + 3;
-= A -= 3; A = A – 3;
*= A *= 3; A = A * 3;
/= A /= 3; A = A / 3;
%= A %= 3; A = A % 3;
++ A ++ A = A + 1;
-- A -- A = A -1;
A partir de agora, utilizaremos estes operadores sempre que possível.
7.6. Loops Infinitos

Um algoritmo entra em Loop, quando ocorre uma situação tal que o mesmo entra em
um laço e não consegue sair deste. Este erro deve ser evitado a todo o custo dentro de
nossos programas. Para uma visualização prática sobre um programa em loop, remova a
linha “valor = valor + 1;” de qualquer um dos exemplos acima citados e veja o
resultado.

1. Faça um algoritmo que calcule a soma de todos os valores inteiros existentes entre 1
e 100. Faça esse algoritmo três vezes, uma para cada laço de repetição.
2. Faça um algoritmo que leia um valor inteiro e calcule a soma de todos os valores
inteiros entre 1 e o valor informado. Faça esse algoritmo três vezes, uma para cada
laço de repetição.
3. Faça um algoritmo que leia um valor inteiro e calcule o seu fatorial. O fatorial de
um número é o resultado da multiplicação deste próprio número pelos seus valores
menores parando no 1. Exemplo: 5! = 5x4x3x2x1 = 120. Faça esse algoritmo três
vezes, uma para cada laço de repetição.

Aula 11
Continuação dos exercícios
4. Faça um programa que leia um número qualquer e calcule a tabuada desse número.
A tabuada deve ser exibida ao usuário no seguinte formato (considerando a leitura
do número 2):
2X1=2
2X2=4
2X3=6
...
2 X 10 = 20
5. Faça um algoritmo que leia dois valores (X e Y) e calcule XY. Obs.: Não utilize a
função “pow”.
6. Faça um algoritmo que leia dois valores positivos (A e B) e calcule a multiplicação

de A por B. Obs.: Não utilize o operador aritmético “*”.
7. Faça um algoritmo que resolva a seguinte situação.

“A empresa de João tem um quadro de 36 funcionários, sendo que a cada ano são
contratados 5 novos colaboradores. Enquanto que a empresa de Joaquim possui um
quadro de 50 funcionários e a cada ano são contratados 3 novos funcionários.
Quantos anos serão necessários para que João ultrapasse Joaquim?”

Aula 12
Continuação dos exercícios (leitura de dados dentro dos laços)
8. Faça um algoritmo que leia um número indeterminado de valores reais e quando for
digitado um valor negativo, exiba a soma destes valores.
9. Faça um algoritmo que leia 25 valores inteiros. Logo após a leitura dos valores,
exiba a média entre os valores.
10. Faça um algoritmo que leia um número indeterminado de valores. E quando for
digitado 0 (zero) exiba a quantidade de números pares e ímpares digitados.
11. Faça um algoritmo que leia 15 valores reais e ao final da leitura exiba o maior valor
informado.
12. Faça um algoritmo que leia 10 nomes e idades. Ao final da leitura exiba o nome da
pessoa mais velha.
13. Faça um algoritmo que leia 50 valores inteiros e logo após a leitura exiba o
percentual de valores múltiplos de 5 digitados.

Aula 13
Continuação dos exercícios
14. Faça um algoritmo que leia um valor inteiro e retorne se este valor é perfeito ou não.
Obs.: Números perfeitos são aqueles cujo a soma de seus divisores (excluindo o
próprio número) formam exatamente o valor original. Exemplo: 6 (1+2+3 = 6)
15. Faça um algoritmo que leia um usuário e senha digitados pelo usuário. O programa
deve exibir a mensagem “Bem Vindo” caso o usuário digitado seja “aluno” e a
senha digitada seja “segredo”. O programa deve avisar quando o login não for
efetuado e emitir um aviso de bloqueio caso o usuário erre seu login três vezes.
16. Faça um programa que leia o Nome, Valor Hora, Total de Horas Trabalhadas e a
idade de 50 funcionários. Após a leitura dos dados exiba:
a) A média salarial bruta da empresa
b) O nome e a idade do funcionário mais velho
c) O nome e o salário do funcionário que tiver a maior renda.

Aula 14
Continuação dos exercícios (desafios)
17. Faça um algoritmo que leia um número inteiro qualquer e retorne se este número é
primo ou não. Obs.: Números primos são aqueles divisíveis apenas por 1 (um) e por
eles mesmos.
18. Faça um algoritmo que leia 3 valores inteiros e exiba o MMC (Mínimo Múltiplo
Comum) entre estes valores.
19. Faça um algoritmo que leia o Nome, Idade e Sexo de 50 pessoas. Retorne ao final o
nome da mulher mais velha e do homem mais jovem.
20. Faça um algoritmo que imprima na tela os 10 primeiros valores da seqüência de

Fibonacci. (1, 1, 2, 3, 5, 8, 13, 21, 34 e 55). Obs.: Utilizar laços para gerar a
seqüência.

Aula 15
Revisão Geral Para a Prova I
Aula destinada a revisão de todo o conteúdo desenvolvido até o momento, bem como
conclusão de exercícios.

Aula 16
Prova I
Boa prova a todos.
Lembrem-se sempre de ler com atenção todas as questões da prova.
Faça primeiro as questões que você considerar mais fáceis.
Não fique com dúvidas em relação à interpretação da prova.

Aula 17
Considerações sobre a prova
Aula destinada a correção da prova e tirar dúvidas em relação a avaliação.

Aula 18
Variáveis Homogêneas Unidimensionais (Vetores)
8. Introdução
A partir deste ponto do curso iremos quebrar o paradigma de que uma variável só pode
armazenar um valor por vez.
8.1. O que são vetores?

Vetores são variáveis como quaisquer outras. Devem possuir nome, tipo de dado e seu
conteúdo pode sofrer alteração durante a execução do programa. Porém, diferente de
uma variável convencional, vetores podem armazenar mais de um valor ao mesmo
tempo. Desde que estejam em posições diferentes.
8.2. Representação Gráfica

Um vetor pode ser representado como uma tabela de apenas uma linha ou coluna.
Na linguagem C, a primeira posição de um vetor é sempre a posição 0 (zero), sendo

crescente a partir deste ponto.
Sendo assim, um vetor de 6 posições possui índice variando entre 0 e 5.
8.3. Utilidade para Vetores

Vetores são de grande utilidade quando precisamos armazenar dados de forma a não
perdermos os dados anteriormente digitados.
8.4. Declarando Vetores

Declarar vetores na linguagem C é relativamente simples.
Sintaxe:
<Tipo de dado> <Nome do vetor> [número de posições];
Exemplos:
int vetor1[10];
float vetor2[15];
Quando o vetor a ser declarado for de tipo char, devemos informar primeiro o número
de caracteres que cada posição irá armazenar e logo após o número de posições.
Exemplo:
char vetor3[20] [12];

8.5. Exemplo Prático

Desenvolver um programa que leia um vetor inteiro de 5 posições e exibir a soma deste
vetor.
#include <stdio.h>
int main()
{
int vetor[5];
int i;
float soma;
for (i = 0; i<5; i++)

{
printf ("Digite um valor: ");
scanf ("%d", &vetor[i]);
}
soma = 0;
for (i = 0; i<5; i++)
{
soma = soma + vetor[i];
//ou soma += vetor[i];
}
printf ("A soma do vetor é: %f \n", soma);

system("PAUSE");
return 0;
}
Explicando o código:
O primeiro laço faz a leitura de dados do vetor de forma seqüencial (posição por
posição) onde a variável “i” serve de índice para o vetor.
O segundo laço faz o que chamamos de varredura no vetor (passar por todas as
posições) de modo que na variável soma seja acumulado o valor de cada posição
do vetor.
O programa poderia ser desenvolvido em apenas um laço, mas está disposto
desta maneira justamente para demonstrar que os dados continuam armazenados
no vetor, mesmo quando a leitura de informações já está posicionada em outra
linha.
Se em algum momento for necessário recuperar alguma informação digitada,
será possível.


1. Faça um algoritmo que leia um vetor de 11 posições de tipo real. Logo após a leitura
dos dados, exiba a média do vetor.
2. Faça um algoritmo que leia um vetor inteiro de 10 posições. Ao final da leitura,

exiba a quantidade de valores pares existentes no vetor.
3. Faça um algoritmo que leia um vetor real de 6 posições e retorne a média dos
valores positivos do vetor.
4. Faça um algoritmo que leia dois vetores reais de 5 posições. Gere um terceiro vetor
de mesmo tamanho e tipo que obedeça a seguinte regra de formação:
a) Na primeira posição do vetor 3 será armazenada a multiplicação entre a primeira
posição do vetor 1 e a primeira posição do vetor 2.
b) Na segunda posição do vetor 3 será armazenada a multiplicação entre a segunda
posição do vetor 1 e a segunda posição do vetor 2.
c) ...
5. Faça um algoritmo que leia um vetor string de 10 posições. Após a leitura de todo o
vetor o usuário deve informar mais uma palavra. Seu programa deve exibir quantas
vezes esta palavra existe no vetor.

Aula 19
Continuação dos Exercícios
6. Faça um algoritmo que leia dois vetores string de 10 posições equivalentes a grade
de respostas de um aluno e o gabarito da mesma prova feita pelo professor. Seu
programa deve informar a nota do aluno sabendo que cada acerto equivale a 1 ponto.
Seu programa também deve retornar uma mensagem para o usuário de acordo com o
seu número de acertos
a) Até 3 acertos: PRECISA MELHORAR
b) Até 5 acertos: REGULAR
c) Até 7 acertos: BOM
d) Acima de 8 acertos: CONTINUE ASSIM.
7. Faça um algoritmo que leia um vetor inteiro de 10 posições. Logo após a leitura de
todo o vetor, inverta os valores de todo o vetor.
8. Faça um algoritmo que leia um vetor real de 8 posições. Logo após a leitura exiba o
maior valor digitado no vetor.
9. Faça um algoritmo que gere um vetor de 10 posições contendo os primeiros 10

valores da seqüência Fibonacci.
10. Faça um algoritmo que leia um vetor de 6 posições inteiro e reorganize os dados
deste vetor de modo que seus dados sejam exibidos de maneira crescente.

Aula 20
Aula destinada à correção dos exercícios e remoção de dúvidas.

Aula 21
Variáveis Homogêneas Multidimensionais (Matrizes)
9. Introdução
Dentro da programação, vetores não são a única forma de se armazenar múltiplos
valores dentro de uma variável.
9.1. O que são Matrizes?

Matrizes possuem rigorosamente a mesma definição de vetores. Porém os seus dados
podem ser armazenados em uma estrutura de dados que possua mais de uma dimensão.
9.2. Representação Gráfica

A representação gráfica de uma matriz depende do número de dimensões que ela
possuir. A forma mais comum de encontrarmos uma matriz é no formato de duas
dimensões.
É indiferente pensarmos que cada posição da matriz é indexada pelo número de sua
coluna seguido por sua linha ou o seu inverso. Para uma maior facilidade de
compreensão, iremos trabalhar com o sistema de linha x coluna.
9.3. Declarando Matrizes.

A declaração de matrizes é similar a declaração de vetores.
Sintaxe:
<Tipo de dado> <Nome da matriz> [número de linhas] [número de colunas];
Exemplos:
int matriz1[10][5];
float matriz2[6][6];
Quando a matriz a ser declarada for de tipo char, devemos informar primeiro o número
de caracteres que cada posição irá armazenar e logo após o número de linhas e colunas.
Exemplo:
char matriz3[20][8][5];


#include <stdio.h>
int main()
{
int matriz[3][3];
int linha,coluna;
float soma;
//Leitura dos dados

for (linha = 0; linha<3; linha++)
{
for (coluna = 0; coluna<3; coluna++)
{
printf ("Digite um valor: ");
scanf ("%d", &matriz[linha][coluna]);
}
}
//Soma e exibição da matriz
soma = 0;
for (linha = 0; linha<3; linha++)
{
for (coluna = 0; coluna<3; coluna++)
{
printf ("%d ", matriz[linha][coluna]);
soma = soma + matriz[linha][coluna];//ou soma +=matriz[linha][coluna];
}
printf("\n");
}
printf("\n A soma da matriz é: %f",soma);
system("PAUSE");
return 0;
}
Explicando o código
Agora a entrada de dados é feita utilizando dois laços e não apenas um.
Repare que para cada volta do laço de linha, o laço de coluna faz três voltas.
Para a varredura da matriz o processo se repete
Para visualizarmos a matriz é interessante que a cada linha seja feita uma quebra
de linha (“\n”) entre os laços.


1. Faça um algoritmo que leia uma matriz 4x4 de tipo real e exiba ao final a sua média.
2. Faça um algoritmo que leia uma matriz 3x5 de tipo inteiro e exiba quantos valores
pares existem na matriz.
3. Faça um algoritmo que leia uma matriz 5x5 de tipo real e exiba a soma das linhas
pares e a média das linhas ímpares.
4. Faça um algoritmo que leia uma matriz 2x8 e coloque seus valores em uma matriz
8x2. Ambas as matrizes de tipo char.
5. Faça um algoritmo que leia uma matriz 6x6 e exiba a soma de sua diagonal
principal.
6. Faça um algoritmo que leia uma matriz 6x6 e exiba a soma de sua diagonal
secundária.
7. Faça um algoritmo que leia uma matriz 6x6 e exiba a soma dos seguintes valores da
matriz.
8. Faça um algoritmo que preencha uma matriz 10x10 de forma automática com os
valores de 1 a 100 de forma seqüencial. Obs.: Utilize apenas os contadores dos laços
e a matriz propriamente dita. Não utilize uma contadora auxiliar.

Aula 22
Aula destinada à conclusão e correção dos exercícios.

Aula 23
Continuação e Correção de Exercícios
9. Faça um algoritmo que leia uma matriz 3x3 de tipo real e adicione seus valores a um
vetor real de 9 posições.
10. Faça um algoritmo que ordene os valores de uma matriz 4x4 de forma decrescente.
O procedimento a ser executado deverá ser:
a) Ler a matriz
b) Adicionar seus dados a um vetor
c) Ordenar o vetor
d) Devolver os dados para a matriz.
11. Faça um algoritmo que ordene de forma crescente apenas os valores pares de uma
matriz inteira 5x5, sendo que os valores ímpares não devem ser deslocados.

Aula 24
Introdução a Programação Modular
10. Introdução
O conceito de programação modular consiste no desenvolvimento de rotinas de tal
forma que seja permitido o seu reaproveitamento.
10.1. Por que Utilizar Programação Modular?

Um algoritmo que implementa programação modular possui inúmeras vantagens.
Dentre as quais se destacam:
O código fonte diminui drasticamente de tamanho
A manutenção do código fonte fica simplificada
Uma possível mudança de plataforma pode ser menos traumática (portabilidade)
Exemplo
Imagine que estamos desenvolvendo um software com uma gama de cálculos
assombrosa. O que aconteceria se uma fórmula muito comum em todo o programa
tenha sido passada errada para o programador? A resposta é simples, reescrever a
fórmula em todos os lugares em que a mesma se encontra. Esse trabalho pode levar
horas, dependendo do tamanho do código.
Se utilizarmos o conceito de programação modular, a alteração precisará ser feita em
apenas um lugar. Sendo que todo o programa irá se atualizar automaticamente.
10.2. Como Implementar Programação Modular?

Programação modular dentro da linguagem C é feita utilizando o que chamamos de
funções.
10.2.1. Funções
Funções são blocos de algoritmo que devem possuir uma assinatura e que ao final
de sua execução, devem retornar algum valor de resposta.
10.2.2. Assinatura
Conjunto formado pelo nome, lista de argumentos (quando necessários) e tipo de
dado de saída.
10.2.3. Argumento
São todas as informações que devem ser enviadas pelo usuário da função, para que
esta possa ser executada de forma correta.
10.2.4. Parâmetro
São as informações que serão passadas para os argumentos das funções pelo
programa principal (usuário).

Utilizando os conceitos de programação modular. Faremos um algoritmo que retorne o
maior valor entre dois valores inteiros.

#include <stdio.h>
//Criação da Função
int encontra_maior(int a, int b)
{
if (a > b)
{
return a;
}
else
{
return b;
}
}
//Programa Principal
int main()
{
int v1, v2, maior;
printf ("Digite o primeiro valor: ");
scanf ("%d", &v1);
printf ("Digite o segundo valor: ");
scanf ("%d", &v2);
maior = encontra_maior(v1,v2);
printf ("O maior valor é: %d \n", maior);
system("PAUSE");
return 0;
}
int encontra_maior(int a, int b) Assinatura da função. Está sendo informado que
existe uma função chamada “encontra_maior”
que recebe dois valores inteiros como argumentos
(a e b) e devolve um valor inteiro no final
Return É a instrução que fará com que a devolução do
valor seja feita. No caso de “a” ser o maior valor
será retornado “a”, caso contrário a função
devolverá “b”.
maior = encontra_maior(v1, v2) Chamada da função. É feita a chamada da função
“encontra_maior” de modo que o conteúdo dos
parâmetros “v1” e “v2” sejam enviados para os
argumentos “a” e “b” e o retorno da função será
depositado na variável “maior”
Repare que em nenhum momento é feita a leitura dos valores dos argumentos dentro da
função. A leitura dos dados deve ser feita nos parâmetros, de modo que a função se
torne o mais independente possível. Exceto em funções específicas para captura de
dados do usuário.
Apesar de funcional, o exemplo acima poderia ser facilmente desenvolvido sem a

utilização de programação modular. Sendo assim, sua utilidade nesta questão é posta em
xeque.

Porém, este tipo de abordagem mostra seu verdadeiro valor com o decorrer do tempo.
Se, por exemplo, fosse necessário agora que a leitura a ser feita seja de três valores
inteiros. Qual seria sua solução? Reescrever a função de modo que encontre o maior
valor entre três parâmetros?.
Preste atenção no exemplo abaixo, ainda utilizando a função “encontra_maior”:
int main()
{
int v1, v2, v3, maior;
scanf ("%d", &v1);
scanf ("%d", &v2);
printf ("Digite o terceiro valor: ");
scanf ("%d", &v3);
maior = encontra_maior(encontra_maior(v1,v2),v3);
printf ("O maior valor é: %d \n", maior);
system("PAUSE");
return 0;
}
Com este método, foi possível reaproveitar o código da função anterior de modo que
encontramos o maior valor entre as variáveis “v1” e “v2” e comparamos este valor com
“v3” em uma segunda chamada da função.
Sendo assim, a função original não precisou sofrer nenhuma alteração na sua estrutura.
Podemos achar o maior valor entre qualquer grupo de valores utilizando a função
“encontra_maior” fazendo alterações apenas no programa principal.
Nada impede também, que façamos mais de uma função dentro de um código. Inclusive
de modo que uma função chame outra que esteja desenvolvida acima.
10.4. Escopo das Variáveis – Instanciamento de Variáveis

Trabalhando com múltiplas funções em um código, é muito comum de termos em
vários pontos do programa variáveis com utilizações totalmente diferentes porém com o
mesmo nome.
Variáveis declaradas dentro de uma função, possuem validade apenas dentro desta
função. Permitindo assim que seu nome seja repetido em outras funções. Estas variáveis
também são conhecidas como variáveis locais.
Existem também, variáveis que podem ter validade dentro de todo o nosso projeto
(sendo visualizadas por todas as funções). Estas são denominadas como variáveis
Globais.
Esta “área de validade” é o escopo de uma variável.


1. Faça um algoritmo que leia 3 valores reais. Crie uma função que retorne a média
entre estes valores.
2. Faça um algoritmo que leia dois valores inteiros e retorna o triplo do maior valor.
3. Faça um algoritmo que recebe o código de um produto e retorna (através de uma

função) o nome do mesmo de acordo com a tabela abaixo:
Código Produto
1 Sanduíche de Presunto
2 Suco de Tamarindo
3 Pastel de Vento
4 Pão com margarina
4. Faça um algoritmo que lê dia, mês e ano vindos do usuário. Crie uma função que
retorne se estes valores formam uma data válida ou não.
5. Faça um algoritmo que lê um número inteiro e que chame uma função que retorne o
seu fatorial.

Aula 25
Continuação dos Exercícios
6. Faça um algoritmo que possua 5 funções
a) Uma que calcule a soma entre dois valores reais
b) Uma que calcule a multiplicação entre dois valores reais
c) Uma que calcule a subtração entre dois valores reais
d) Uma que calcule a divisão entre dois valores reais
e) Uma que de acordo com um código fornecido pelo usuário chama as funções
acima conforme a tabela abaixo:
Código Ação
1 Adição
2 Multiplicação
3 Subtração
4 Divisão
Crie um programa principal que deve apenas ler o código da operação e dois valores
reais e exiba o resultado da operação.
10.6. Passagem de Parâmetros por Valor e Referência

Como dito anteriormente, quando chamamos uma função, o conteúdo existente nos
parâmetros são enviados para os argumentos da função para o seu tratamento. Este
processo chama-se Passagem de Parâmetros, sendo que este tipo de passagem pode
ser feita de duas formas:
Por valor ou cópia: O conteúdo dos argumentos e parâmetros são
independentes. Ou seja, a alteração do conteúdo do argumento não influencia no
conteúdo do parâmetro.
Por referência: O conteúdo dos argumentos e parâmetros são interligados, ou
seja, compartilham o mesmo endereço de memória. Sendo assim, a alteração de
um argumento influencia diretamente no conteúdo de seu parâmetro
correspondente.
Na linguagem C, a passagem de parâmetros não está bem definida, sendo feita através
da utilização de ponteiros.
Na linguagem C, sempre que passamos um vetor ou matriz como parâmetro, este é
passado por “referência”.


Para melhor entendermos a passagem por parâmetros por valor e referência, façamos
como exemplo um programa que inverte o conteúdo entre duas variáveis inteiras.
A função desta vez não irá devolver um valor oficialmente, mas como devemos sempre
informar um tipo de dado de saída, utilizaremos o tipo de dado void.
Forma ERRADA de desenvolvimento

#include <stdio.h>
void inverte(int a, int b)
{
int aux;
aux = a;
a = b;
b = aux;
}
int main()
{
int a,b;
scanf("%d", &a);
scanf("%d", &b);
inverte (a, b);
printf ("O novo valor de A é: %d\n", a);
printf ("O novo valor de B é: %d\n", b);
system("PAUSE");
return 0;
}
A função apenas inverte os valores, não há a necessidade de utilizarmos a instrução

“return” justamente por ser de retorno void.
Ao testarmos o programa, veremos que o código fonte acima apesar de compilar não
resolve nosso problema, pois as variáveis não mudaram de valor.
Isso acontece por que a passagem de parâmetros na linguagem C é em sua grande
maioria passada por valor.
Para solucionar o problema acima, devemos fazer algumas modificações no código,

para forçar a passagem de parâmetros por referência.

Forma CORRETA de desenvolvimento
#include <stdio.h>
void inverte(int *a, int *b)
{
int aux;
aux = *a;
*a = *b;
*b = aux;
}
int main()
{
int a,b;
scanf("%d", &a);
scanf("%d", &b);
inverte (&a, &b);
printf ("O novo valor de A é: %d\n", a);
printf ("O novo valor de B é: %d\n", b);
system("PAUSE");
return 0;
}
Na função a única diferença é que nossos argumentos devem ser precedidos pelo
operador “*”, assim estamos nos referenciando diretamente ao endereço do argumento
na memória.
No programa principal, os parâmetros devem ser precedidos pelo operador “&” para
que seja passado para o argumento a posição da variável na memória em vez do seu
conteúdo propriamente dito.

7. Faça um algoritmo que leia três valores reais e que possua uma função que devolva
os valores de x’ e x” de acordo com a fórmula abaixo. No caso de erro, devolver
zero.
b b2 4 * a * c
x' , x"
2*a
8. Faça um algoritmo que leia dois valores reais e possua uma função que retorna o
dobro do maior valor e a metade do menor.

Aula 26
Tratando Vetores Através de Funções
Para tratarmos vetores (ou qualquer estrutura de dados) de uma forma eficiente e
organizada, é aconselhável que utilizemos funções de manipulação para estes dados.
Faremos agora um exemplo prático implementando a manipulação de um vetor de
modo que sejam feitas as quatro operações básicas para um sistema.
Inserção
Alteração
Exclusão
Pesquisa
Este projeto deve ser bem planejado, para que seu desenvolvimento seja de fácil
compreensão. Sendo assim, iremos trabalhar passo a passo o código fonte.

Dev C ++

Caricato da

Informazioni sul documento

Descrizione originale:

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Dev C ++

Caricato da

Copyright:

Formati disponibili

QI - Escola de Educação Profissional

Apostila de Lógica de Programação

APOSTILA DE LÓGICA DE PROGRAMAÇÃO

Direitos autorais reservados à:

Professor: Eduardo Reus Souza 1

Professor: Eduardo Reus Souza 2

Professor: Eduardo Reus Souza 3

Professor: Eduardo Reus Souza 4

Professor: Eduardo Reus Souza 5

1.1. Lógica e Lógica de Programação

1.5. Formas de se representar um Algoritmo

Professor: Eduardo Reus Souza 6

1.6. Regras para a Criação de Algoritmos

Entrada Processamento Saída

É importante ressaltar que:

1.7. Como proceder na construção de algoritmos?

1.7.1. Leia com atenção o enunciado do problema

1.7.2. Obtenha os dados de entrada

Professor: Eduardo Reus Souza 7

1.7.4. Determinar o que deve ser feito para transformar as

1.7.5. Testar o algoritmo

1.8. Exercícios propostos

Professor: Eduardo Reus Souza 8

2. Variáveis e Constantes de memória (RAM)

2.2. Como um programa é tratado na memória?

2.5. Regras para formação de Identificadores

Professor: Eduardo Reus Souza 9

2.6. Tipos de Dados

2.7. Principais tipos de dados utilizados na disciplina

2.8. Exercícios Propostos

Professor: Eduardo Reus Souza 10

3.1. Linguagens de Baixo Nível

3.2. Linguagens de Alto Nível

3.4. Estrutura padrão de um algoritmo (C)

Professor: Eduardo Reus Souza 11

Explicando o código acima

valor2 = 15500; Atribui o valor 15500 para a variável valor2

Professor: Eduardo Reus Souza 12

3.6. Operadores aritméticos

* Para que as funções “pow” e “sqrt” possam funcionar corretamente, devemos

3.7. Regras de precedência de operadores

3.8. Exercícios Propostos

2. Faça um algoritmo que calcule a área de um quadrado de lado L= 10.

3. Faça um algoritmo que calcule a hipotenusa de um triângulo retângulo de catetos

4. Faça um algoritmo que efetue as seguintes operações:

Professor: Eduardo Reus Souza 13

media = (v1 + v2)/2.0;

printf ("A sua media é: %f", media);

Professor: Eduardo Reus Souza 14

printf ("Digite o seu nome: ");

media = (v1 + v2)/2.0;

3.10. Exercícios Propostos

Professor: Eduardo Reus Souza 15

Professor: Eduardo Reus Souza 16

4.1. O que é DEV-C++?

4.2. Versão do DEV-C++

4.3. Interface do Software

Professor: Eduardo Reus Souza 17

Escolha a opção Console Application, certificando-se que a opção “Projeto C” esteja

Professor: Eduardo Reus Souza 18

Repare que existe uma linha obrigatória no final do código fonte:

4.4. Compilando um Projeto