Aula 15 — Escopo de Variáveis

1. O que é Escopo?

Toda variável em C tem um escopo: a região do código onde ela existe e pode ser acessada. Fora desse escopo, a variável simplesmente não existe — tentar usá-la gera erro de compilação.

C reconhece quatro categorias de escopo:

2. Variáveis Locais (Escopo de Bloco)

Uma variável declarada dentro de um par de chaves { } é local àquele bloco. Ela nasce quando o programa entra no bloco e morre quando sai.

#include <stdio.h>

void exemploLocal() {
    int x = 10;                  // x existe apenas dentro de exemploLocal

    if (x > 5) {
        int y = 20;              // y existe apenas dentro deste if
        printf("x=%d y=%d\n", x, y);   // OK: x e y visíveis aqui
    }

    // printf("%d", y);          // ❌ ERRO: y não existe mais aqui
    printf("x=%d\n", x);        // OK: x ainda existe aqui
}                                // x é destruída ao sair de exemploLocal

int main() {
    exemploLocal();
    // printf("%d", x);          // ❌ ERRO: x não existe em main
    return 0;
}

Variável de controle do for (C99)

Declarar a variável de controle dentro do próprio for limita seu escopo ao bloco do loop — uma boa prática:

for (int i = 0; i < 5; i++) {
    printf("%d ", i);     // OK: i existe dentro do for
}
// printf("%d", i);       // ❌ ERRO: i não existe fora do for (C99)

int x;                   // ❌ contém lixo — valor imprevisível
printf("%d\n", x);       // comportamento indefinido!

int y = 0;               // ✅ sempre inicialize antes de usar

3. Variáveis Globais (Escopo de Arquivo)

Uma variável declarada fora de qualquer função — normalmente no topo do arquivo — é global. Ela é visível em todas as funções do arquivo e existe durante toda a execução do programa.

#include <stdio.h>

int contador = 0;           // global — visível em todas as funções
const float TAXA = 0.05f;   // constante global — uso adequado

void incrementar() {
    contador++;             // acessa e modifica a global diretamente
}

void exibir() {
    printf("Contador: %d | Taxa: %.0f%%\n", contador, TAXA * 100);
}

int main() {
    exibir();           // Contador: 0 | Taxa: 5%
    incrementar();
    incrementar();
    incrementar();
    exibir();           // Contador: 3 | Taxa: 5%
    return 0;
}

Variáveis globais são inicializadas automaticamente com zero

Ao contrário das locais, variáveis globais são sempre zeradas antes do programa começar:

4. Sombreamento (Shadowing) — Local Esconde Global

Quando uma variável local tem o mesmo nome de uma variável global, a local sombreia (esconde) a global dentro do seu escopo. A global continua existindo, mas fica temporariamente inacessível pelo nome.

#include <stdio.h>

int valor = 100;            // global

void demonstrar() {
    printf("global: %d\n", valor);   // 100 — ainda sem sombra

    int valor = 50;                  // local — cria sombra sobre a global
    printf("local:  %d\n", valor);   // 50

    {
        int valor = 25;              // bloco interno — sombra da sombra
        printf("bloco:  %d\n", valor); // 25
    }

    printf("local:  %d\n", valor);   // 50 — volta ao escopo local
}

int main() {
    demonstrar();
    printf("global: %d\n", valor);   // 100 — global intocada
    return 0;
}

5. Quando Usar (e Quando Evitar) Variáveis Globais

int resultado;              // global desnecessária
void somar(int a, int b) {
    resultado = a + b;      // qualquer função pode corromper isso
}

int somar(int a, int b) {
    return a + b;           // limpo, sem efeitos colaterais
}

6. Variável Local static — Persistindo Entre Chamadas

C tem um tipo especial de variável local: a variável local static. Ela tem escopo local (só visível dentro da função) mas duração global — não é destruída ao retornar e persiste entre chamadas.

#include <stdio.h>

void contarChamadas() {
    static int n = 0;       // inicializada UMA vez; persiste entre chamadas
    n++;
    printf("Esta função foi chamada %d vez(es)\n", n);
}

int main() {
    contarChamadas();   // Esta função foi chamada 1 vez(es)
    contarChamadas();   // Esta função foi chamada 2 vez(es)
    contarChamadas();   // Esta função foi chamada 3 vez(es)
    return 0;
}

Comparação: local normal vs local static vs global

Exemplo prático: gerador de ID único

#include <stdio.h>

int gerarID() {
    static int proximoID = 1000;   // começa em 1000, nunca reinicia
    return proximoID++;
}

int main() {
    printf("ID: %d\n", gerarID());   // ID: 1000
    printf("ID: %d\n", gerarID());   // ID: 1001
    printf("ID: %d\n", gerarID());   // ID: 1002
    return 0;
}

7. Escopo de Parâmetros

Os parâmetros de uma função têm escopo equivalente ao de variáveis locais declaradas no início do corpo. Eles existem enquanto a função está executando e são destruídos ao retornar.

#include <stdio.h>

void processar(int valor, float taxa) {
    // 'valor' e 'taxa' existem aqui — escopo idêntico ao de locais
    valor = valor + (int)(valor * taxa);   // modifica a cópia local
    printf("Valor processado: %d\n", valor);
}   // 'valor' e 'taxa' são destruídos aqui

int main() {
    int preco = 100;
    processar(preco, 0.1f);
    printf("Preço original: %d\n", preco);   // 100 — intocado
    return 0;
}

8. Exemplo Completo — Todos os Escopos em Um Programa

#include <stdio.h>

/* ── ESCOPO GLOBAL ─────────────────────────────── */
int totalVendas = 0;                   // global: visível em todo o arquivo
const float IMPOSTO = 0.12f;           // constante global: uso adequado

float calcularPrecoFinal(float preco, int quantidade) {
    /* ── ESCOPO DE PARÂMETRO ────────────────── */
    // 'preco' e 'quantidade' existem apenas aqui

    /* ── ESCOPO LOCAL (bloco da função) ────── */
    float subtotal = preco * quantidade;
    float imposto  = subtotal * IMPOSTO;   // usa constante global
    float total    = subtotal + imposto;

    /* ── STATIC LOCAL ───────────────────────── */
    static int numTransacoes = 0;          // persiste entre chamadas
    numTransacoes++;

    /* ── ESCOPO DE BLOCO (if interno) ───────── */
    if (total > 500.0f) {
        float desconto = total * 0.05f;    // existe apenas neste if
        total -= desconto;
        printf("  Desconto de 5%% aplicado: -R$%.2f\n", desconto);
    }   // 'desconto' destruída aqui

    totalVendas++;                         // modifica global
    printf("  Transacao #%d | Total: R$%.2f\n", numTransacoes, total);
    return total;
}

int main() {
    printf("=== Caixa da Loja ===\n");
    calcularPrecoFinal(80.0f,  3);   // 3 x R$80  = R$240 + imposto
    calcularPrecoFinal(200.0f, 4);   // 4 x R$200 = R$800 -> desconto!
    calcularPrecoFinal(50.0f,  2);   // 2 x R$50  = R$100 + imposto
    printf("\nTotal de vendas no sistema: %d\n", totalVendas);
    return 0;
}

9. C vs. Java — Escopo de Variáveis

Side-by-side: variável global em C vs atributo estático em Java

int contador = 0;

void incrementar() {
    contador++;
}

int obter() {
    return contador;
}

class Contador {
    static int valor = 0;

    static void incrementar() {
        valor++;
    }

    static int obter() {
        return valor;
    }
}