Aula 02 – Variáveis e Tipos de Dados

O que é uma Variável?

Uma variável é um espaço reservado na memória do computador que recebe um nome e armazena um valor que pode ser alterado durante a execução do programa. Em C, antes de usar qualquer variável, é obrigatório declará-la indicando seu tipo de dado.

A sintaxe básica de declaração é:

tipo nomeDaVariavel;                   // declaração
tipo nomeDaVariavel = valorInicial;    // declaração com inicialização

Exemplos práticos:

int idade = 25;          // inteiro
float altura = 1.75;     // ponto flutuante simples
double massa = 70.345;   // ponto flutuante duplo
char inicial = 'A';      // caractere único

Tipos Inteiros

Os tipos inteiros armazenam números sem parte fracionária. C oferece quatro variações, com diferentes tamanhos e faixas de valores:

#include <stdio.h>

int main() {
    short   s = 30000;
    int     i = 2000000;
    long    l = 2000000000L;      // sufixo L para long
    long long ll = 9000000000LL;  // sufixo LL para long long

    unsigned int ui = 4000000000U; // sufixo U para unsigned

    printf("short:     %d\n",   s);
    printf("int:       %d\n",   i);
    printf("long:      %ld\n",  l);   // %ld para long
    printf("long long: %lld\n", ll);  // %lld para long long
    printf("unsigned:  %u\n",   ui);  // %u para unsigned int

    return 0;
}

Tipos de Ponto Flutuante

Os tipos de ponto flutuante armazenam números com parte fracionária. C oferece três variações com diferentes precisões:

#include <stdio.h>

int main() {
    float  f = 3.14159f;       // sufixo f para float literal
    double d = 3.141592653589793;
    float  altura = 1.75;

    printf("float:  %.5f\n", f);   // %.5f = 5 casas decimais
    printf("double: %.15f\n", d);  // mostra a maior precisão do double
    printf("altura: %.2f m\n", altura);

    return 0;
}

Tipo Caractere: char

O tipo char armazena um único caractere usando a codificação ASCII. Ocupa exatamente 1 byte (8 bits) de memória. Na prática, um char é um número inteiro pequeno — cada caractere tem um código numérico correspondente.

#include <stdio.h>

int main() {
    char letra = 'A';
    char digito = '7';

    printf("Caractere: %c\n", letra);    // imprime: A
    printf("Código ASCII: %d\n", letra); // imprime: 65 (%d lê o char como inteiro)
    printf("Próxima letra: %c\n", letra + 1); // imprime: B (65+1 = 66)

    return 0;
}

Tabela ASCII — caracteres mais comuns

Tipo Booleano em C

Ao contrário do Java, que possui o tipo primitivo boolean com os valores true e false, o C originalmente não tinha um tipo booleano. A lógica booleana era implementada com inteiros:

// C antes do C99 — usando int para lógica booleana
int ativo = 1;   // verdadeiro
int inativo = 0; // falso

if (ativo) {
    printf("Sistema ativo!\n");  // este bloco executa
}

A partir do padrão C99, foi introduzido o header <stdbool.h>, que define o tipo bool e as constantes true e false formalmente:

#include <stdio.h>
#include <stdbool.h>   // necessário para usar bool em C99+

int main() {
    bool aprovado = true;
    bool reprovado = false;

    if (aprovado) {
        printf("Aluno aprovado!\n");
    }

    printf("Valor de true:  %d\n", true);   // imprime 1
    printf("Valor de false: %d\n", false);  // imprime 0

    return 0;
}

Verificando o Tamanho dos Tipos: sizeof

O operador sizeof retorna o número de bytes que um tipo ou variável ocupa na memória. É muito útil para entender como o C aloca espaço e para escrever código portável entre diferentes plataformas e sistemas operacionais.

#include <stdio.h>

int main() {
    printf("char:        %zu byte(s)\n",  sizeof(char));
    printf("short:       %zu byte(s)\n",  sizeof(short));
    printf("int:         %zu byte(s)\n",  sizeof(int));
    printf("long:        %zu byte(s)\n",  sizeof(long));
    printf("long long:   %zu byte(s)\n",  sizeof(long long));
    printf("float:       %zu byte(s)\n",  sizeof(float));
    printf("double:      %zu byte(s)\n",  sizeof(double));
    printf("long double: %zu byte(s)\n",  sizeof(long double));
    return 0;
}

Exemplo Completo: Lendo Diferentes Tipos

O programa abaixo, baseado no material de referência do curso, demonstra como declarar, inicializar e ler variáveis dos três tipos principais. Observe o uso de <locale.h> para suporte a acentos:

#include <stdio.h>
#include <locale.h>   // necessário para exibir caracteres acentuados

void main() {
    setlocale(LC_ALL, "");  // ativa o suporte à língua local (acentos)

    printf("Olá \n");

    // ── Inteiro ───────────────────────────────────
    int a = 50;
    printf("O valor de a é = %d \n", a);
    printf("Informe o novo valor de a: ");
    scanf("%d", &a);
    printf("O valor de a mudou para %d \n", a);

    // ── Ponto flutuante ───────────────────────────
    float b = 5.5;
    printf("O valor de b é = %f \n", b);
    printf("Informe o novo valor de b: ");
    scanf("%f", &b);
    printf("O valor de b mudou para %f \n", b);

    // ── Caractere ─────────────────────────────────
    char letra = 't';
    printf("O valor de c é = %c \n", letra);
    printf("Informe o novo valor de c (letra): ");
    scanf(" %c", &letra);  // espaço antes de %c descarta o '\n' do buffer
    printf("O valor de c mudou para %c\n", letra);
}

Conversão de Tipos (Type Casting)

Quando valores de tipos diferentes são combinados em uma expressão, o C realiza conversões de tipo — de forma automática (implícita) ou forçada pelo programador (explícita).

Conversão Implícita (automática)

O C promove automaticamente o tipo "menor" para o tipo "maior" em uma expressão:

int    i = 7;
double d = 2.5;
double resultado = i + d;  // i é promovido para double automaticamente
printf("%.1f\n", resultado);  // 9.5

Conversão Explícita (cast)

Para forçar uma conversão, use o operador de cast (tipo) antes do valor:

#include <stdio.h>

int main() {
    int a = 7, b = 2;

    // sem cast: divisão inteira (descarta o resto)
    printf("Sem cast: %d\n", a / b);         // 3

    // com cast: converte a para double antes de dividir
    printf("Com cast: %.1f\n", (double)a / b);  // 3.5

    return 0;
}

Tipos em C versus Java

A tabela abaixo compara os tipos primitivos das duas linguagens. As semelhanças são grandes — a principal diferença está no que não existe em C: