Variáveis e Constantes em Programação

Prévia do material em texto

1
Algoritmos e 
Técnicas de 
Programação
Variáveis, Constantes e Operações
Profa. Dra. Jenai Oliveira Cazetta
Contextualização
Pensar sobre o problema;Pensar sobre o problema;
Rascunhar uma primeira solução;Rascunhar uma primeira solução;
Preocupar com os detalhes.Preocupar com os detalhes.
DOCUMENTAÇÃO
Resolução de 
problemas
Fonte: https://cutt.ly/EfFOiyK
Programas de computadores são construídos seguindo um conjunto de regras 
e técnicas bastante especificas.
Nessa era digital é imprescindível que profissionais de diversas áreas 
aprendam essas ferramentas, para que possam contribuir e evoluir em sua 
área de atuação.
Fonte: https://cutt.ly/EfFOiyK
Como abordar um problema de programação?
• Projete seu programa antes de programá-lo;
• Escreva um código legível;
• Comente seu código enquanto escreve, não depois;
• Utilize margens e indentação apropriadamente;
• Use nomes sugestivos para as variáveis, funções e procedimentos;
• Utilize funções e procedimentos curtos e objetivos.
Observações
• A maior parte do tempo que se gasta programando
corrigindo e modificando código existente;
• Você gastará muito tempo lendo o seu código faz
sentido gastar algum tempo aprendendo a escrever um
código legível;
• Código legível fácil de escrever, fácil de depurar e/ou
compilar e fácil de manter.
DADOS 
PRIMITIVOS
DADOS 
PRIMITIVOS
DADOS 
COMPOSTOS
DADOS 
COMPOSTOS
OPERAÇÕES E 
EXPRESSÕES
OPERAÇÕES E 
EXPRESSÕES
Nossa teleaula
2
Tipos de dados e 
modificadores
Variáveis e constantes
• São endereços de memória de trabalho que guardam, temporariamente,
um valor utilizado/calculado pelo programa.
• Independente da linguagem, os dados serão armazenados em variáveis.
• Para cada tipo de dado será especificado um tipo de variável e,
consequentemente, um determinado espaço físico.
Memória de Trabalho
A B
Cuidado!!!
Fonte: https://cutt.ly/EfFOiyK
As variáveis, quando criadas, 
existem de fato na memória 
de trabalho e, portanto, 
ocupam um espaço físico. 
O mesmo se aplica às 
constantes, porém, o 
valor armazenado nunca 
será alterado.
Fonte: https://cutt.ly/EfFOiyK
definição do 
rótulo de 
identificação 
da variável 
na memória! 
quantidade 
de bytes que 
será 
reservada na 
memória!
Declaração de uma variável
<tipo> <nome_da_variável>;
• Inteiro: armazena os números inteiros;
int valor1,valor2,soma;
• Real: armazena valores de pontos flutuantes;
float valor1,valor2,soma;
• Caractere: caracteres, números e símbolos especiais (‘ ‘) / (” “). 
char nome1,nome2;
Observações
• Ao criar uma variável podemos optar por já 
atribuir um valor;
• Quando a variável for:
• numérica inicialize-a com zero;
• booleana inicialize-a com falso; 
• caractere inicialize-a com 
“ “ para atribuir vazio.
#include <stdbool.h>
void main()
{
int idade;
float salario=7500;
double qtd_atomos;
bool confirma=false;
char genero=“ ”;
} 
3
Limitação dos valores e modificadores
• Quantidade de espaço alocado para determinada variável
depende do tipo de variável tipo de dado limita o
valor que pode ser guardado naquele espaço;
• Exemplo:
• variável do tipo int alocados 4 bytes na memória 
32 bits;
• 1 byte unidade de informação digital 8 bits;
• 1 bit só pode armazenar um 0 ou um 1.
Modificadores de tipos
• Comandos usados na declaração da variável que modificam
sua capacidade padrão suprem parte da limitação;
Tipo Tamanho
(bytes)
Valores
int 4 −2.147.423.648 𝑎 2.147.423.648
unsigned int 4 4.294.967.296
short int 2 −32.768 𝑎 32.767
float 4 −3,4 𝑎 3,4
double 8 −1,7 𝑎 1,7
long double 16 −3,4 𝑎 1,1
Processamento de 
dados
Processamento de dados
• As variáveis e as constantes podem
ser utilizadas na elaboração de
cálculos matemáticos com o auxílio
de operadores aritméticos;
• Um dos maiores desafios garantir
que a lógica esteja correta;
• Ao escrever uma expressão
matemática é preciso se atentar à
ordem de precedência dos
operadores.
Ordem de precedência:
(1) ( );
(2) potenciação e radiciação;
(3) multiplicação, divisão e módulo;
(4) soma e subtração.
Operadores 
aritméticos
Operador Descrição Exemplo Resultado
+ soma 4 + 2 6
− subtração 4 − 2 2
∗ multiplicação 4 ∗ 2 8
/ divisão 4/2 2
= atribuição 𝑥 = 4 𝑥 = 4
% resto 
4%2 0
21%2 1
Operador Descrição Exemplo Resultado
+ manutenção de sinal +2 2
− inversão de sinal −2 −2
+ + incremento de 1 em 1 𝑥 + + + +𝑥 𝑥 + 1
− − decremento de 1 em 1 𝑥 − − − −𝑥 𝑥 − 1
BI
N
ÁR
IO
S
U
N
ÁR
IO
S
// biblioteca necessária
#include <math.h>
𝑥 pow(x,y)
𝑥  sqrt(x)
Potenciação e 
radiciação?
Fonte: https://bit.ly/3aLma1DFonte: https://cutt.ly/EfFOiyK
4
Atribuição de valores e operações aritméticas
( ou =) função de indicar 
valores para as variáveis, ou seja, 
atribuir informação para a variável.
valor  5;
valor = 5;
soma  valor1 + valor2;
soma = valor1 + valor2;
𝑥 = 43 55 ÷ 30 + 2 
𝑦 = 𝑥 + 2𝑥 + 3
𝐴 = 𝜋𝑟 
𝐴 =
𝑏ℎ
2
 
𝑥 = (43 ∗ 55/(30 + 2));
𝑦 = 𝑥^2 + 2 ∗ 𝑥 + 3;
𝑎𝑟𝑒𝑎 = 𝑀_𝑃𝐼 ∗ 𝑟𝑎𝑖𝑜^3;
𝑎𝑟𝑒𝑎 = 𝑏𝑎𝑠𝑒 ∗ 𝑎𝑙𝑡𝑢𝑟𝑎 /2;
Operadores relacionais – Expressões booleanas
Comparações entre valores resultado verdadeiro (1) ou falso (0).
Operador Descrição Exemplo
== igual a 𝑥 == 𝑦
! = diferente de 𝑥! = 𝑦
> maior que 𝑥 > 𝑦
< menor que 𝑥 < 𝑦
> = maior ou igual a 𝑥 > = 𝑦
< = menor ou igual a 𝑥 < = 𝑦
Exemplo: Comparando dois números
#include<stdio.h>
int main()
{
//declarando variáveis
int N1=0;
int N2=0;
//armazenando dados
printf("Digite o 1º numero: ");
scanf("%d",&N1);
printf("Digite o 2º numero: ");
scanf("%d",&N2);
//comparando os dados armazenados e fornecendo o 
resultado (booleano)
printf(“ \nN1 e N2 sao iguais? %d",N1==N2);
printf(“ \nN1 e maior que N2? %d",N1>N2);
printf(“ \nN1 e menor ou igual a N2? %d",N1<=N2);
//finalizando o programa
printf(“ \nPressione a tecla enter para sair!");
return 0;
}
Operadores lógicos e 
teste de mesa
Operadores lógicos
Descrição Exemplo Resultado
! negação (not) ! (𝑥 == 𝑦) inverte o resultado
&& conjunção (and)
𝑥 > 𝑦
&&
(𝑎 == 𝑏)
todas as alternativas 
devem ser V  V
∥ disjunção (or)
𝑥 > 𝑦
∥
(𝑎 == 𝑏)
basta uma condição 
ser V  V
5
#include<stdio.h>
int main() {
//declarando variáveis
int a, b, c;
//armazenando dados
printf(“ \nDigite o valor de a: ");
scanf(“%d“,a);
printf(" \nDigite o valor de b: ");
scanf(“%d“,b);
printf(" \nDigite o valor de c: ");
scanf(“%d“,c);
//comparando dados e imprimindo resultados
printf(“ \n(a=b) e (a=c)? %d",((a==b)&&(a==c)));
printf(" \n(a=b) ou (a=c)? %d",((a==b)||(a==c)));
printf(" \n(a!=b) ou (a=c)? %d",((a!=b)||(a==c)));
//encerrando o programa
printf(" \nPressione a tecla enter para sair!");
return 0;
}
Teste de mesa
Se você estiver confuso ao tentar procurar 
algum problema no seu programa, tente 
explicá-lo para você mesmo. 
Dessa forma é possível notar 
inconsistências ou fugas ao 
algoritmo planejado!
Fonte: https://cutt.ly/EfFOiyK
Teste de mesa – Exemplo1
#include <stdio.h>
#include <stdlib.h>
int main(void) {
//declarando variávies
float nota1,nota2,media;
//armazenando dados
printf(“ \nDigite a primeira nota: ");
scanf("%f",&nota1);
printf(" \nDigite a segunda nota: ");
scanf("%f",&nota2);
Digite a primeira nota:
nota1 = 4.0
Digite a segunda nota: 
nota2 = 8.0
8.0
4.0
1
//calculando média
media = (nota1+nota2)/2;
//fornecendo resultados
printf(" \nMedia do aluno = %.2f",media);
printf(" \nMedia e maior ou igual a 6.0? %d",media>=6.0);
printf(" \nPressione a tecla enter para sair!");
return 0;
}
media =(4.0+8.0)/2
Media do aluno=6.00 
Media e maior ou igual a 6?
Teste de mesa – Exemplo 2
#include<stdio.h>
int main() {
//declarando variáveis
int a, b, c;
//armazenando dados
printf(“\nValor de a: ");
scanf(“%d“,a);
printf(“\nValor de b: ");
scanf(“%d“,b);
printf(“\nValor de c: ");
scanf(“%d“,c);
//imprimindo valores
printf(“ \n(a=b) e (a=c)? %d",((a==b)&&(a==c)));
printf(" \n(a=b) ou (a=c)? %d",((a==b)||(a==c)));
printf(" \n(a!=b) ou (a=c)? %d",((a!=b)||(a==c)));
printf(" \nPressionea tecla enter para sair!");
return 0;}
Valor de a:
Valor de b:
Valor de c:
4
2
4
(a=b) e (a=c)?
(a=b) ou (a=c)?
(a!=b) ou (a=c)?
0
1
1
6
Calculando o salário 
de um funcionário
Atividade
• Programa em C calcular o salário líquido de um 
funcionário de certa empresa levando em consideração o 
número de horas trabalhadas. 
Salário bruto = (horas trabalhadas).(valor hora)
Valor hora trabalhada = (1/10).(salário mínimo)
Imposto = 3% do salário bruto
Salário líquido = (salário bruto) – (imposto)
ENTRADAENTRADA
• Número de 
horas 
trabalhadas
• Valor do salário 
mínimo
PROCESSAMENTOPROCESSAMENTO
• Valor da hora 
trabalhada
• Salário bruto
• Imposto
• Salário líquido
SAÍDASAÍDA
• Valor da hora 
trabalhada
• Salário bruto
• Imposto
• Salário líquido
#include<stdio.h>
int main()
{
//declarando variáveis
float num_horas, salario_min,valor_hora,salario_bruto,
imposto, salario_liquido;
//lendo e armazenando dados
printf(“ \nDigite o numero de horas trabalhadas: ");
scanf("%f",&num_horas);
printf(“ \nDigite o valor do salario minimo: ");
scanf("%f",&salario_min);
//processando os dados
valor_hora = salario_min/10;
salario_bruto = num_horas*valor_hora;
imposto = 0.03*salario_bruto;
salario_liquido = salario_bruto – imposto;
//imprimindo dados processados
printf(“ \n\nValor da hora trabalhada: %.2f", valor_hora);
printf(“ \nSalario bruto: %.2f",salario_bruto);
printf(“ \nImposto arrecadado: %.2f",imposto);
printf(“ \nSalario a receber: %.2f",salario_liquido);
//encerrando o programa
printf(“ \n Pressione a tecla enter para sair!");
return 0;
}
7
Variáveis e 
constantes
Variáveis e constantes
Há diferença entre a 
declaração de uma variável e 
a de uma constante?
Fonte: https://cutt.ly/EfFOiyK
Variáveis compostas
Considere a seguinte situação
• Você precisa cadastrar as notas de 6 alunos e calcular a 
média semestral de cada um deles.
Existe problema técnico em 
criar 18 variáveis para 
armazenar os valores?
Fonte: https://cutt.ly/EfFOiyK
Variáveis compostas – Estruturas de dados
Melhor solução para armazenar diversos valores dentro de um mesmo 
contexto armazenar diversos valores em um endereço de memória.
Estrutura de dados: 
vetores, matrizes, 
registros, filas, pilhas, etc.
Fonte: https://cutt.ly/EfFOiyK
Memória de Trabalho
A B
Memória de Trabalho
A B
Memória de Trabalho
A
8
Se os vários valores têm 
os mesmos endereços, 
como diferenciar um do 
outro?
Fonte: https://cutt.ly/EfFOiyK
Variáveis compostas ou indexadas
• Variáveis compostas ou variáveis indexadas possuem
um endereço na memória e índices para identificar
seus subespaços;
• Formadas a partir dos tipos primitivos; 
• Classificadas em:
• homogêneas e heterogêneas, 
• unidimensionais ou multidimensionais,
• estáticas ou dinâmicas.
Destacam-se em termos de 
performance, pois cada dado é 
alocado sequencialmente na memória, 
tornando seu acesso extremamente 
rápido.
Fonte: https://cutt.ly/EfFOiyK
Variáveis compostas 
homogêneas
//criação
<tipo> <nome_do_vetor>[tamanho];
Variáveis compostas homogêneas unidimensionais
• Vetores estrutura de uma tabela contendo apenas 1 coluna e N linhas 
(1 linha e N colunas); 
• Estrutura estática seu tamanho deve ser informado no momento da 
criação e não é alterado por nenhum recurso em tempo de execução.
//criação
int V[3];
//armazenamento 
printf(“Digite um valor: “);
scanf(“%d”,&V[1]); 
//impressão 
printf (“ ∖nV[1] = %d”,V[1]);
V[0]
V[1]
V[2]
Memória de TrabalhoMemória de Trabalho
V[0] V[1] V[2]
//atribuição de valores
V[0] = 2;
V[2] = 1;
2 1
9
Variáveis compostas homogêneas multidimensionais
• Matrizes estrutura de uma tabela contendo N colunas e M linhas;
• Estrutura estática seu tamanho deve ser informado no momento da
criação e não é alterado por nenhum recurso em tempo de execução.
//criação
<tipo> <nome_da_matriz>[linhas][colunas];
//criação
int M[3][2];
//armazenamento 
printf(“Digite um valor: “);
scanf(“%d”, &M[2][1]); 
//impressão 
printf (“ ∖nM[2][1] = %d”,M[2][1]);
M[0][0]
M[0][1]
M[1][0]
M[1][1]
M[2][0]
M[2][1]
Memória de Trabalho
M[0][0] M[0][1]
M[1][0] M[1][1]
M[2][0] M[2][1]
0
-2
//atribuição valores A[0][1] = 1;
A[1][0] = 0;
A[2][1] = -2;
1
Exemplo
#include<stdio.h>
main() 
{
//declarando variáveis
float notas[2][3];
//armazenando dados
ENTRADAENTRADA
• Notas de dois 
alunos
PROCESSAMENTOPROCESSAMENTO
• Média das notas 
dos dois alunos
SAÍDASAÍDA
• Média das notas 
dos dois alunos
//Aluno 1
printf(“ \n\nAluno 1");
printf(“ \nDigite a 1ª nota: ");
scanf("%f",&nota[1][0]);
printf(“ \nDigite a 2ª nota: ");
scanf("%f",&nota[1][1]);
//Aluno 2
printf(“ \n\nAluno 2");
printf(“ \nDigite a 1ª nota: ");
scanf("%f",&nota[2][0]);
printf(“ \nDigite a 2ª nota: ");
scanf("%f",&nota[2][1]);
//calculando e imprimindo dados
printf(“ \n\nAluno 1");
nota[1][2] = (nota[1][0] + nota[1][1])/2;
printf(" \nNota 1: %.2f",nota[1][0]);
printf(" \nNota 2: %.2f",nota[1][1]);
printf(“ \nMedia: %.2f",nota[1][2]);
printf(“ \n\nAluno 2");
nota[2][2] = (nota[2][0] + nota[2][1])/2;
printf(“ \nNota 1: %.2f",nota[2][0]);
printf(“ \nNota 2: %.2f",nota[2][1]);
printf(“ \nMedia: %.2f",nota[2][2]);
printf(“ \nPressione enter para sair!");
return 0 }
Eu não poderia declarar 
uma estrutura com 2 
linhas e 4 colunas e 
armazenar o nome do 
aluno?
Fonte: https://cutt.ly/EfFOiyK
Variáveis compostas 
heterogêneas
10
Variáveis compostas heterogêneas
• Estruturas ou registros structs;
• Exemplo: ficha de cadastro de um cliente com diversos campos
nome, idade, CPF e endereço;
• Exemplo: Nome, notas e médias de um conjunto de alunos;
• Criação antes da função main().
struct <nome>
{
<tipo> <nome_variavel1>;
<tipo> <nome_variavel2>;
//...
//...
};
Acesso aos dados da struct
O acesso aos dados é feito usando o
nome da variável, que recebeu como tipo
a estrutura composta heterogênea, com
um ponto (.) e o nome do campo:
dadosvariavel.campo1
//no programa principal, antes de utilizar a estrutura, ela deverá 
ser invocada
struct nome dadosnome1;
//...
dadosautomovel1.modelo
dadosautomovel1.ano
dadosautomovel1.valor
struct automovel
{
char modelo[20];
int ano;
float valor;
};
Exemplo
• Programa variável composta heterogênea
armazenar os dados de um automóvel;
• Programa deverá receber os dados digitados (modelo,
ano e valor) pelo usuário e armazenar nos respectivos
campos e, por fim, imprimir os valores que foram
atribuídos.
#include<stdio.h>
//definindo o tipo de registro
struct automovel
{
char modelo[20];
int ano;
float valor;
};
main()
{
//”chamando” o registro
struct automovel dadosautomovel1;
//pedindo ao usuário para digitar os dados e 
armazenando-os nos respectivos campos
printf(“ \nDigite o modelo do automovel: ");
scanf("%s",&dadosautomovel1.modelo);
printf(“ \nDigite o ano do automovel: ");
scanf("%d",&dadosautomovel1.ano);
printf(“ \nDigite o valor do automovel: ");
scanf("%f",&dadosautomovel1.valor);
11
//imprimindo os dados informados
printf(“ \nDados");
printf(" \nModelo: %s",dadosautomovel1.modelo);
printf(" \nAno: %d",dadosautomovel1.ano);
printf(" \nValor: %f",dadosautomovel1.valor);
//encerrando o programa
printf(“ \nPressione a tecla enter para sair!");
return 0;
}
Estatística de veículos
Atividade 
• Programa em C calcular a quantidade média de veículos registrados no 
estado de São Paulo em cada ano, usando os dados da tabela.
Tipo de 
Veículo
Quantidade de veículos por ano
2017 2018 2019
Carro 16.319.979 16.834.629 17.247.123
Moto 4.133.366 4.268.872 4.378.772
Caminhão 658.713 664.617 669.056
Dados em 
português!
• Qual a média de veículos registrados em 2017, em 2018 e 
em 2019? 
• Qual ano obteve a maior média? 
• Quantidade anual de 
carros, motos e 
caminhões
ENTRADAENTRADA
• Média anual de carros, 
motos e caminhões
PROCESSAMENTOPROCESSAMENTO • Média anual de carros, 
motos e caminhões
• Ano em que a média foi 
maior
SAÍDASAÍDA
Estrutura de dados 
homogênea unidimensional!
Fonte: https://cutt.ly/EfFOiyK
#include<stdio.h>main() 
{
//declarando variáveis
int ano_2017[3]={0};
int ano_2018[3]={0}; 
int ano_2019[3]={0};
float media_2017=0;
float media_2018=0;
float media_2019=0;
//inserindo os valores e armazenando os dados
printf(“ \nNumero de carros em 2017: ”);
scanf(“%d”,&ano_2017[0]);
printf(" \nNumero de motos em 2017: ”);
scanf(“%d”,&ano_2017[1]);
printf(" \nNumero de caminhões em 2017: ”);
scanf(“%d”,&ano_2017[2]);
printf(" \nNumero de carros em 2018: ”);
scanf(“%d”,&ano_2018[0]);
printf(" \nNumero de motos em 2018: ”);
scanf(“%d”,&ano_2018[1]);
printf(" \nNumero de caminhoes em 2018: ”);
scanf(“%d”,&ano_2018[2]);
12
printf(“ \nNumero de carros em 2019: ”);
scanf(“%d”,&ano_2019[0]);
printf(" \nNumero de motos em 2019: ”);
scanf(“%d”,&ano_2019[1]);
printf(" \nNumero de caminhões em 2019: ”);
scanf(“%d”,&ano_2019[2]);
//calculando as médias
media_2017=(ano_2017[0]+ano_2017[1]+ano_2017[2])/3;
media_2018=(ano_2018[0]+ano_2018[1]+ano_2018[2])/3;
media_2019=(ano_2019[0]+ano_2019[1]+ano_2019[2])/3;
//imprimindo as médias calculadas
printf(“ \nMedia em 2017: %.2f”,media_2017);
printf(“ \nMedia em 2018: %.2f”,media_2018);
printf(“ \nMedia em 2019: %.2f”,media_2019);
//comparando as médias
printf(“ \n2017 obteve a maior media? %d”,
((media_2017 > media_2018)&&(media_2017 > media_2019)));
printf(“ \n2018 obteve a maior media? %d”, 
((media_2018 > media_2017)&&(media_2018 > media_2019)));
printf(“ \n2019 obteve a maior media? %d”, 
((media_2019 > media_2017)&&(media_2019 > media_2018)));
//encerrando o programa
printf(“ \nPressione a tecla enter para sair!");
return 0;
}
Vetores de caracteres
Caracteres
Como eu posso ler uma 
frase digitada na tela do 
computador para, 
depois, imprimí-la?
Fonte: https://cutt.ly/EfFOiyK
Recapitulando
13
Variáveis
int −2.147.423.648 𝑎 2.147.423.648
unsigned int 4.294.967.296
short int −32.768 𝑎 32.767
float −3,4 𝑎 3,4
double −1,7 𝑎 1,7
long double −3,4 𝑎 1,1
char −128 𝑎 127
Operadores aritméticos
+ soma + manutenção de sinal
− subtração − inversão de sinal
∗ multiplicação + + incremento de 1 em 1 
/ divisão − − decremento de 1 em 1
= atribuição
% resto 
(1) ( ); 
(2) potenciação e radiciação;
(3) multiplicação, divisão e módulo; 
(4) soma e subtração.
#include<math.h>
𝑥 pow(x,y)
𝑥  sqrt(x)
Operadores relacionais
== igual a 𝑥 == 𝑦
! = diferente de 𝑥! = 𝑦
> maior que 𝑥 > 𝑦
< menor que 𝑥 < 𝑦
> = maior ou igual a 𝑥 > = 𝑦
< = menor ou igual a 𝑥 < = 𝑦
Operadores lógicos
! negação (not) ! (𝑥 == 𝑦)
&& conjunção (and) 𝑥 > 𝑦 && (𝑎 == 𝑏)
∥ disjunção (or) 𝑥 > 𝑦 ∥ (𝑎 == 𝑏)
Estruturas de dados estáticas homogêneas
Vetor
<tipo> <nome_do_vetor>[tamanho];
scanf(“%d”,&vetor[1]); 
printf(“vetor[1] = %d”,vetor[1]);
Matriz
<tipo> <nome_da_matriz>[linhas][colunas];
scanf(“%d”,&matriz[2][1]); 
printf (“matriz[2][1] = %d”,matriz[2][1]);
Estruturas de dados estáticas heterogêneas - Registro
struct <nome> 
{
<tipo> <nome_variavel1>;
<tipo> <nome_variavel2>;
//... 
};
struct automovel
{
char modelo[20];
int ano;
float valor; 
};
variavel.campo; dadosautomovel1.modelo
scanf("%d",&dadosautomovel1.ano);
printf("%s",dadosautomovel1.valor);