C Academy · Lección

Variables static

Locales persistentes

Variables static es una lección gratuita de C Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C Academy incluye 4 lecciones en total.

La palabra clave static

Una variable local static conserva su valor entre las llamadas a la función. Su duración abarca todo el programa.

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

Se inicializa una sola vez

Una variable static se inicializa únicamente la primera vez que se ejecuta la función. En las llamadas posteriores se omite el inicializador.

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

Cero predeterminado

A diferencia de las variables auto, una variable static sin inicializador comienza en 0.

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

Contar llamadas

Un uso clásico consiste en contar cuántas veces se ha invocado una función.

#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;
}

Duración static, ámbito local

Una variable local static sigue teniendo ámbito local. Solo la función puede verla, pero persiste entre las llamadas.

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

static frente a auto

Compare: un contador auto se reinicia en cada llamada, mientras que uno static acumula su valor.

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

static en el ámbito de archivo

En el ámbito de archivo, static significa enlace interno: la variable es privada de su archivo fuente.

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

Almacenamiento en caché con static

Las variables static pueden almacenar en caché un valor calculado para que se calcule una sola 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;
}

Acumulación de estado

Las variables locales static permiten que una función recuerde un total acumulado sin utilizar una variable 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;
}

Una precaución

El estado static hace que una función dependa de su historial, lo que puede dificultar las pruebas. Utilícelo de forma deliberada.

#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;
}

Combinación con bucles

Una variable local static dentro del cuerpo de un bucle conserva su valor tanto entre iteraciones como entre llamadas.

#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;
}

Comprobación rápida

Compruebe su comprensión de las variables static.

Repaso: variables static

Ha aprendido sobre las variables locales persistentes.

Las variables locales static viven durante todo el programa
Se inicializan una vez y su valor predeterminado es 0
Mantienen el ámbito local, pero conservan sus valores
En el ámbito de archivo, static proporciona enlace interno
Son excelentes para contadores y cachés

Preguntas frecuentes

¿La lección «Variables static» es gratis?

Sí — el texto completo de «Variables static» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C Academy, actualiza a CoddyKit PRO. El curso de C Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Variables static»?

Locales persistentes Practicas C Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C Academy?

No se requiere experiencia previa. C Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Variables static»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C Academy?

Sí. Cada lección de C Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C Academy