Etapa 2 - Variáveis e Saída de Dados
Todo programa de computador realiza processamento sobre dados. Imagine um programa que realiza a leitura de um sensor de temperatura a cada minuto de uma sala e, caso o valor esteja acima de um limite, emita um alerta de segurança. Onde será que esses dados de temperatura que o computador “lê” ficam armazenados? No nosso problema, nós também temos que armazenar dados, afinal, nosso programa opera sobre um dado de Delta S (ΔS) e um dado de Delta T (Δt), gerando um terceiro dado, que é a velocidade média.
Desse modo, os dados utilizados e gerados pelo programa são armazenados em variáveis na memória principal do computador, chamada Memória RAM. Essa memória é responsável por armazenar instruções e dados enquanto os programas estão executando no computador.
Você pode imaginar a memória RAM como um armário com várias gavetas, onde cada gaveta tem um endereço específico em formato Hexadecimal. Veja o armário abaixo, onde cada gaveta representa uma posição de memória RAM e possui um endereço em hexadecimal único (3C01, 3C02, …).
Cada gaveta da memória é utilizada para armazenar um dado em formato binário, como o nosso Delta S e Delta T, por exemplo. Podemos armazenar tanto números, como textos nas “gavetas” de memória.
Declarando Variáveis
Quando identificamos a necessidade de armazenar algum dado, devemos reservar uma dessas gavetas criando variáveis. Dessa forma, atribuímos um nome que fica associado a uma dessas gavetas para utilizarmos. Em C, devemos declarar as variáveis logo no início do programa com o seu tipo de dado e o seu nome. Veja a variável “delta_s” abaixo.
#include <stdio.h>
int main(void) {
int delta_s;
return 0;
}
A declaração de uma variável sempre inicia com o tipo de dado que a “gaveta” vai armazenar e um nome válido, para que possamos utilizar no restante do programa. O int indica que a “gaveta” irá armazenar um número inteiro. O nome da “gaveta” é definido após o tipo: delta_s.
Como resultado do comando int delta_s, uma gaveta é reservada e o nome é relacionado ao endereço da gaveta na memória RAM, como uma espécie de “apelido” para ela. Agora, podemos armazenar e operar com dados guardados nessa gaveta utilizando o seu “apelido” delta_s.
Antes de pedirmos os valores de Delta S e Delta T ao usuário, vamos brincar um pouco com a variável delta_s que declaramos para compreender melhor o conceito.
Atribuindo Valores às Variáveis
Imagine que desejamos guardar o dado inteiro 200 na variável delta_s. Para isso devemos utilizar o operador “=”, chamado operador de atribuição. Veja abaixo.
#include <stdio.h>
int main(void) {
int delta_s;
delta_s = 200;
return 0;
}
Ao se deparar com o comando delta_s = 200, o computador pensa o seguinte.
Fonte: https://quantumcomputingtech.blogspot.com/2018/09/thinking-computers.html
Chamamos o operador “=” de operador de atribuição ou “recebe” e podemos ler o comando como “delta_s recebe 200”. Portanto, utilizamos o “recebe” para inserir ou alterar valores nas variáveis. Se fizermos uma nova atribuição de oturo valor em uma outra linha do nosso programa, o anterior será apagado.
Como nós também vamos precisar de mais variáveis para armazenar o Delta T e a velocidade média que será calculada.
Passo 1 - Insira a variável inteira delta_t e atribua o valor 2 a ela. Veja como fica o código:
#include <stdio.h>
int main(void) {
int delta_s;
int delta_t;
delta_s = 200;
delta_t = 2;
return 0;
}
Passo 2 - declare a variável inteira v_media. O código desta etapa deve ficar assim:
#include <stdio.h>
int main(void) {
int delta_s;
int delta_t;
int v_media;
delta_s = 200;
delta_t = 2;
return 0;
}
Operando com Variáveis
Até agora aprendemos que variáveis são “gavetas” na memória do computador que servem para armazenar dados. Mas, o que fazemos com esses dados armazenados então? Como calculamos, por exemplo, a velocidade média a partir dos valores em delta_s e delta_t?
Você vai ver que é muito simples fazer calculos matemáticos com as variáveis. Basta utilizarmos os operadores de soma (+), subtração (-), multiplicação (*) e divisão (/), assim como numa calculadora normal. Veja como ficaria o cálculo da velocidade média em C:
v_media = delta_s/delta_t;
Parace uma expressão matemática, não é? A diferença é que a expressão acima faz a divisão do valor guardado em delta_s pelo valor em delta_t, e armazena o resultado em uma terceira variável v_media. Essa é a matemática sendo executada pelo computador.
Lembrando que as variáveis devem sempre ser declaradas no início do programa e devemos digitar os seus nomes extamente iguais aos que utilizamos na declaração. Não podemos declarar o nome “delta_s” e digitar “deltas” ou “deltaS” nas linhas do nosso programa. O computador não irá reconhecer as variáveis se houver diferença nos nomes!
Até o momento, o nosso código com o cálculo da velocidade média está da seguinte forma:
#include <stdio.h>
int main(void) {
int delta_s;
int delta_t;
int v_media;
delta_s = 200;
delta_t = 2;
v_media = delta_s/delta_t;
return 0;
}
A tabela abaixo mostra os operadores matemáticos que podemos utilizar em nossos programas.
|
Operador |
Descrição |
Exemplo de Uso: suponha as variáveis var1 e var2 |
|
+ |
Soma |
var1 + var2 |
|
- |
Subtração |
var1 - var2 |
|
* |
Multiplicação |
var1 * var2 |
|
/ |
Divisão |
var1 / var2 |
|
% |
Resto: obtém o resto da divisão entre dois números |
var1 % var2 |
Saída de Dados
Neste ponto, temos as variáveis delta_s e delta_t armazenando os valores 200 e 2, respectivamente, e a variável v_media com o valor da divisão de delta_s por delta_t. Porém, se executarmos esse programa, não veremos absolutamente nada na tela do console. Como podemos, então, mostrar o valor da velocidade média na tela para que o usuário do programa o veja?
Para isso, precisamos de uma função de saída de dados, que irá escrever para nós o valor na tela. A função padrão para saída de dados em C é a printf() da biblioteca stdio.h. Vamos aprender a utilizá-la.
1 - Digite o código a seguir na linha abaixo do cálculo da velocidade média.
printf("A velocidade média foi de %d quilômetros por hora\n", v_media);
2 - Execute o programa e veja o resultado na tela do console.
Até esse momento o seu código deve ser o seguinte:
#include <stdio.h>
int main(void) {
int delta_s;
int delta_t;
int v_media;
delta_s = 200;
delta_t = 2;
v_media = delta_s/delta_t;
printf("A velocidade média foi de %d quilômetros por hora\n",v_media);
return 0;
}
Importante!
Nesse caso, temos uma divisão exata dos valores das variáveis, porém, nem sempre esse é o caso. Imagine que o valor de delta_t seja igual a 3. Desse modo, v_media terá aproximadamente 66,67. Um valor fracionário!
O tipo inteiro (int) não é o único disponível para variáveis, podemos ter tipos para números fracionários também. Para utilizá-lo, basta colocar a palavra-chave float antes do nome da variável.
Entendendo a função printf()
A função printf recebe um texto entre aspas com uma marcação %d e a variável v_media, que contém o resultado do cálculo de delta_s/delta_t. Ao executar, o computador subsituiu a marcação %d pelo valor da variável v_media e o texto foi apresentado com o valor 100 na tela.
Veja em detalhes cada parte da função printf que escrevemos:
Chamamos os valores que informamos para a função entre parêntesis ( ) de argumentos, no caso da printf, temos dois argumentos. O primeiro é o texto entre aspas, o segundo é a variável v_media cujo valor será mostrado junto ao texto.
Vamos entender um pouco mais sobre a marcação %d e sua relação com o valor da variável v_media. Veja o esquema abaixo.
Você pode imaginar a função printf como uma caixa de processamento de informação que realiza a tarefa de imprimir a mensagem na tela. Os argumentos separados por vírgula são valores que jogamos dentro dessa caixa para que ela realize o seu trabalho. De posse do texto e da variável v_media, printf irá internamente verificar a marcação no texto e subsituir pelo valor que estiver armazenado em v_media, que neste caso é o número 100.
Muita atenção com a vírgula, pois, ela é quem separa os argumentos da função.
Por último, você deve ter reparado que, ao final do texto, temos o \n. Este é um caractere especial que manda o computador pular para a linha seguinte após imprimir o texto.