C Academy · Aula

Variáveis static

Variáveis locais persistentes.

Variáveis static é uma aula grátis de C Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C Academy inclui 4 aulas no total.

A palavra-chave estática

Uma variável local static mantém seu valor entre as chamadas da função. Seu tempo de vida é igual ao do programa inteiro.

#include <stdio.h>
void f(void) {
    static int count = 0;
    count++;
    printf("count = %d\n", count);
}
int main(void) {
    f();
    f();
    f();
    return 0;
}

Inicializada uma única vez

Uma variável estática é inicializada somente na primeira vez que a função é executada. Nas chamadas seguintes, o inicializador é ignorado.

#include <stdio.h>
void f(void) {
    static int x = 100;
    printf("x = %d\n", x);
    x += 10;
}
int main(void) {
    f();
    f();
    return 0;
}

Zero por padrão

Ao contrário das variáveis auto, uma variável static sem inicializador começa com 0.

#include <stdio.h>
void f(void) {
    static int n;
    printf("n = %d\n", n);
    n++;
}
int main(void) {
    f();
    f();
    return 0;
}

Contando chamadas

Um uso clássico é contar quantas vezes uma função foi chamada.

#include <stdio.h>
int nextId(void) {
    static int id = 0;
    return ++id;
}
int main(void) {
    printf("%d %d %d\n", nextId(), nextId(), nextId());
    return 0;
}

Tempo de vida estático, escopo local

Uma variável local estática ainda tem escopo local. Somente a função pode acessá-la, mas ela persiste entre as chamadas.

#include <stdio.h>
void tick(void) {
    static int t = 0;
    t++;
    printf("tick %d\n", t);
}
int main(void) {
    tick();
    tick();
    return 0;
}

Estática e automática

Compare: um contador auto é reiniciado a cada chamada, enquanto um contador static acumula valores.

#include <stdio.h>
void autoCounter(void) {
    int c = 0;
    c++;
    printf("auto: %d\n", c);
}
int main(void) {
    autoCounter();
    autoCounter();
    return 0;
}

Estática no escopo do arquivo

No escopo do arquivo, static significa ligação interna: a variável fica privada ao seu arquivo-fonte.

#include <stdio.h>
static int secret = 7;
int main(void) {
    printf("secret = %d\n", secret);
    return 0;
}

Armazenamento em cache com variáveis estáticas

As variáveis estáticas podem armazenar em cache um valor calculado, para que ele seja calculado somente uma vez.

#include <stdio.h>
int getBase(void) {
    static int base = 0;
    if (base == 0) {
        base = 50;
        printf("computed once\n");
    }
    return base;
}
int main(void) {
    printf("%d\n", getBase());
    printf("%d\n", getBase());
    return 0;
}

Acumulando estado

As variáveis locais estáticas permitem que uma função se lembre de um total acumulado sem usar uma variável global.

#include <stdio.h>
int addToTotal(int v) {
    static int total = 0;
    total += v;
    return total;
}
int main(void) {
    printf("%d\n", addToTotal(10));
    printf("%d\n", addToTotal(5));
    return 0;
}

Um cuidado

O estado estático faz uma função depender do histórico, o que pode dificultar os testes. Utilize-o de forma intencional.

#include <stdio.h>
int stepNumber(void) {
    static int s = 0;
    return ++s;
}
int main(void) {
    printf("step %d\n", stepNumber());
    printf("step %d\n", stepNumber());
    return 0;
}

Combinando com laços

Uma variável local estática dentro do corpo de um laço mantém seu valor entre as iterações e também entre as chamadas.

#include <stdio.h>
void run(void) {
    static int seen = 0;
    for (int i = 0; i < 2; i++)
        seen++;
    printf("seen = %d\n", seen);
}
int main(void) {
    run();
    run();
    return 0;
}

Verificação rápida

Verifique sua compreensão sobre variáveis estáticas.

Recapitulação: variáveis estáticas

Você aprendeu sobre variáveis locais persistentes.

As variáveis locais static existem durante todo o programa
Elas são inicializadas uma vez e começam com 0 por padrão
Mantêm o escopo local, mas preservam seus valores
No escopo do arquivo, static fornece ligação interna
São excelentes para contadores e caches

Perguntas Frequentes

A aula “Variáveis static” é grátis?

Sim — o texto completo de “Variáveis static” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C Academy, atualize para CoddyKit PRO. O curso de C Academy inclui 4 aulas no total.

O que vou aprender em “Variáveis static”?

Variáveis locais persistentes. Você pratica C Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C Academy?

Nenhuma experiência prévia é necessária. C Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Variáveis static”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C Academy?

Sim. Cada aula de C Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C Academy