Variáveis e Tipos de Dados: Inteiro, Real, Texto e Lógico

1. O Que É Uma Variável? A Gaveta Etiquetada da Memória

Se a memória RAM é um gigantesco armário com bilhões de compartimentos numerados em código hexadecimal (como 0x7FFE001A), como seria o trabalho de um programador se ele precisasse memorizar esses endereços para cada dado manipulado? Seria humanamente impossível.

É exatamente aqui que entra a genialidade do conceito de variável: uma variável é um apelido legível por humanos atribuído a uma região reservada da memória RAM. Em vez de ordenar ao processador "busque o valor contido no endereço físico 0x004F2B", você simplesmente diz "some 1 à variável idade".

Toda variável na ciência da computação é composta por quatro propriedades inseparáveis:

• Identificador (Nome): A etiqueta externa da gaveta (ex: precoUnitario, nomeCliente).
• Endereço Físico: A localização exata dos transistores onde os elétrons estão retidos na placa-mãe.
• Tipo de Dado: O molde arquitetural que define quantos bytes de memória a gaveta ocupa e quais cálculos podem ser feitos.
• Conteúdo (Valor): A informação guardada provisoriamente dentro da gaveta, que pode variar ao longo da execução.

2. Os 4 Tipos Primitivos de Dados Fundamentais

Assim como na vida cotidiana você não guarda moedas em um copo furado nem armazena água em uma gaveta de madeira, na programação cada informação exige um contêiner sob medida. Os processadores modernos foram construídos sobre quatro tipos primitivos essenciais:

1. O Tipo Inteiro (numero no logicabr.dev, int em outras linguagens)

Representa números pertencentes ao conjunto matemático dos números inteiros (\(\mathbb{Z}\)), ou seja, valores positivos, negativos ou nulo que não possuem casas decimais.

• Exemplos válidos: 0, 42, -18, 2026, 1000000.
• Casos de uso reais: Idade de uma pessoa, quantidade de itens no carrinho de compras, número de filhos, ano do calendário, índice de repetição de um laço.
• Alocação de memória típica: 4 bytes (32 bits), permitindo representar números de -2.147.483.648 até +2.147.483.647.

2. O Tipo Real (numero ou moeda no logicabr.dev, float/double em outras linguagens)

Representa números racionais e reais (\(\mathbb{R}\)) que possuem fração ou casas decimais, conhecidos tecnicamente na computação como números de ponto flutuante (Floating-Point).

• Exemplos válidos: 3.14159, -0.75, 19.90, 0.0.
• Atenção à sintaxe: Em todas as linguagens de programação, a separação decimal é feita obrigatoriamente por ponto (.) e nunca por vírgula. Escrever 19,90 gerará um erro sintático fatal.
• Casos de uso reais: Preços em dinheiro, peso em quilogramas, altura em metros, temperaturas, médias escolares com decimais e coordenadas de GPS.

3. O Tipo Texto (texto ou string)

Representa uma cadeia ordenada de caracteres alfanuméricos e símbolos (letras, dígitos, espaços em branco e pontuação). Na memória do computador, cada caractere é mapeado para um código numérico universal padronizado pela tabela Unicode (UTF-8).

• Exemplos válidos: "Ana Clara", "Avenida Paulista, 1000", "senha@123", "" (cadeia vazia).
• Regra mandatória: Todo valor literal do tipo texto deve estar delimitado por aspas duplas. Se você esquecer as aspas e escrever nome = Carlos, o compilador procurará desesperadamente uma variável chamada Carlos e travará com erro.

4. O Tipo Lógico (logico ou boolean)

Criado pelo matemático britânico George Boole em 1847, o tipo lógico é o mais conciso e poderoso da computação. Ele aceita exclusivamente dois estados binários possíveis:

• verdadeiro (ou true / bit 1)
• falso (ou false / bit 0)

Valores lógicos formam a espinha dorsal de qualquer decisão algorítmica: o usuário está autenticado? O saldo bancário é suficiente? O aluno atingiu nota 7? Se a resposta for sim, o estado é verdadeiro; caso contrário, é falso.

3. Segurança de Tipos (Type Safety) e Moldes na RAM

Por que não podemos simplesmente guardar qualquer informação sem declarar o tipo de dado? A resposta está na física da CPU. O processador utiliza circuitos eletrônicos completamente diferentes para somar números inteiros (na Unidade Lógica e Aritmética - ALU) e para calcular números decimais (na Unidade de Ponto Flutuante - FPU).

Quando dizemos numero idade, o compilador prepara um molde rígido. Se mais adiante você tentar fazer idade = "trinta", o sistema emitirá um erro de Incompatibilidade de Tipos (Type Mismatch). Isso não é um defeito da linguagem; é um recurso de segurança que impede que falhas silenciosas cheguem aos usuários finais.

4. Regras de Nomenclatura e Boas Práticas (Clean Code)

O computador não se importa se a sua variável se chama x ou salarioMensalBruto; para ele, ambas são apenas posições de memória. No entanto, o código é escrito para humanos lerem e apenas incidentalmente para computadores executarem.

Regras Obrigatórias de Compiladores (Sintaxe Rígida)

1. Nunca inicie o nome com dígitos: nota1 é perfeitamente válido; 1nota causará erro sintático de compilação.
2. Espaços em branco são estritamente proibidos: O computador interpreta um espaço como o término de uma instrução. Em vez de preco total, use precoTotal ou preco_total.
3. Evite acentos ortográficos e cedilhas: Embora interpretadores modernos permitam caracteres UTF-8, o padrão industrial mundial recomenda evitar acentos (use preco em vez de preço, e descricao em vez de descrição) para evitar incompatibilidade entre sistemas operacionais diferentes.
4. Não utilize palavras reservadas: Palavras como se, senao, enquanto, numero, texto e retorno pertencem ao vocabulário interno da linguagem e não podem batizar variáveis.

Padrões de Nomenclatura da Indústria

• camelCase (Mais comum): Primeira palavra minúscula, e a primeira letra das palavras seguintes maiúscula: saldoDisponivel, quantidadeProdutos.
• snake_case: Todas as letras minúsculas separadas por sublinhado: saldo_disponivel, quantidade_produtos.
• SCREAMING_SNAKE_CASE: Reservado exclusivamente para valores constantes que nunca mudam: TAXA_JUROS_MENSAL, VALOR_PI.

5. Declaração vs Inicialização: Como Criar Variáveis na Prática

Trabalhar com variáveis envolve dois momentos cronológicos distintos no fluxo do programa:

// 1. DECLARAÇÃO E INICIALIZAÇÃO no logicabr.dev:
numero contador = 1;
moeda precoKg = 14.50;
texto nomeProduto = "Maçã Gala";
logico emPromocao = verdadeiro;

// 2. Outras atribuições diretas
numero pontos = 100;

6. Os 5 Erros Mais Comuns de Tipagem em Iniciantes

Mesmo programadores experientes ocasionalmente tropeçam em regras de tipagem. A lista a seguir resume as armadilhas mais frequentes e suas soluções definitivas:

7. Exercício Prático Resolvido: Ficha Cadastral e IMC Completo

Para demonstrar como os 4 tipos primitivos trabalham em harmonia, vamos implementar um algoritmo profissional de triagem de saúde que cadastra um paciente, calcula seu Índice de Massa Corporal (IMC) e verifica se ele atingiu a maioridade:

// 1. Coleta de dados com mensagens de orientação interativas
texto nomePaciente = entrada("Informe o nome completo do paciente:");
numero idade = entrada("Informe a idade (anos inteiros):");
numero pesoKg = entrada("Informe o peso em kg (ex: 78.5):");
numero alturaM = entrada("Informe a altura em metros (ex: 1.75):");

// 2. Processamento Matemático e Lógico
numero imc = pesoKg / (alturaM * alturaM);
logico maiorDeIdade = idade >= 18;

// 3. Emissão da Ficha Cadastral Formatada
saida("==========================================");
saida("FICHA DE SAÚDE DO PACIENTE");
saida("==========================================");
saida("Paciente: " + nomePaciente);
saida("Idade: " + idade + " anos");
saida("Maior de idade: " + maiorDeIdade);
saida("Índice de Massa Corporal (IMC): " + imc);
saida("==========================================");

Acompanhamento pelo Teste de Mesa (Trace Table)

Abaixo simulamos a execução passo a passo com uma paciente fictícia chamada "Beatriz", de 20 anos, 60.0 kg e 1.60 m de altura:

8. Perguntas Frequentes sobre Variáveis e Tipos (FAQ)