Desafio C

Módulo com static e extern

Enunciado

Crie dois arquivos: contador.c e main.c. No contador.c, defina uma variável global int total e uma função void incrementa(void) que a incrementa. Use static para uma variável auxiliar interna e extern no main.c para acessar total. O main deve chamar incrementa três vezes e imprimir o valor de total após cada chamada.

Requisitos

  • O arquivo contador.c deve conter a definição de total e a função incrementa.
  • O arquivo main.c deve usar extern int total; para acessar a variável.
  • A função incrementa deve usar uma variável static local para contar quantas vezes foi chamada.
  • A saída deve mostrar total após cada chamada: 1, 2, 3.

Código inicial

// contador.c
#include <stdio.h>

int total = 0;

void incrementa(void) {
    // use static local e incremente total
}

// main.c
#include <stdio.h>

extern int total;
void incrementa(void);

int main(void) {
    // chame incrementa 3 vezes e imprima total
    return 0;
}

Saída esperada

total: 1
total: 2
total: 3
Ver dica

No contador.c, declare static int chamadas = 0; dentro de incrementa e incremente total. No main.c, apenas declare extern int total; e chame a função.

Mostrar solução

contador.c

#include <stdio.h>

int total = 0; // definição da variável global

void incrementa(void) {
    static int chamadas = 0; // static local: conta chamadas
    chamadas++;
    total++;
    // (opcional) printf("chamadas: %d\n", chamadas);
}

main.c

#include <stdio.h>

extern int total; // declaração: total está definido em outro arquivo
void incrementa(void);

int main(void) {
    incrementa();
    printf("total: %d\n", total);
    incrementa();
    printf("total: %d\n", total);
    incrementa();
    printf("total: %d\n", total);
    return 0;
}

Passo a passo

  1. Em contador.c, int total = 0; define uma variável global com tempo de vida estático e escopo de arquivo (pode ser acessada por outros arquivos).
  2. A função incrementa declara static int chamadas = 0;. Essa variável é inicializada uma vez e mantém o valor entre chamadas, embora só seja visível dentro da função.
  3. A cada chamada, chamadas++ e total++ incrementam os respectivos contadores.
  4. Em main.c, extern int total; informa ao compilador que total existe em outro módulo, sem alocar nova memória.
  5. O main chama incrementa três vezes e imprime total após cada chamada, mostrando 1, 2 e 3.

Por que funciona

extern permite que múltiplos arquivos compartilhem a mesma variável global. static local garante que a contagem de chamadas persista sem poluir o escopo global. A combinação demonstra como controlar visibilidade e tempo de vida em projetos com múltiplos arquivos.

Erros comuns

  • Definir total em ambos os arquivos: int total = 0; em main.c causaria erro de linkagem (símbolo duplicado). Use apenas extern para declarar.
  • Esquecer extern: sem a declaração, o compilador não conhece total e gera erro.
  • Não compilar os dois arquivos juntos: é preciso usar gcc contador.c main.c -o programa.
  • Usar static em total: se total fosse static em contador.c, não seria visível em main.c.

Outra forma de resolver

Colocar tudo em um único arquivo, usando static global para limitar a visibilidade. É preferível para programas pequenos, mas a separação em módulos é melhor para projetos maiores.

Saída esperada

total: 1
total: 2
total: 3