Variables en C: declarar, inicializar y asignar

Una variable es un trozo de memoria con nombre que contiene un valor que tu programa puede leer y cambiar. En C dices de antemano qué clase de valor contiene, y esa elección es permanente durante toda la vida de la variable.

Declarar una variable

La forma es tipo, nombre, punto y coma:

int age;
double price;
char grade;

Cada línea reserva memoria suficiente para ese tipo de dato y le adjunta un nombre. Todavía no se ha guardado nada: el espacio existe, pero su contenido es lo que haya dejado ahí lo que se ejecutara antes.

Puedes dar un valor en el mismo momento, lo que se llama inicialización:

#include <stdio.h>

int main(void) {
    int age = 30;
    double price = 19.99;
    char grade = 'A';

    printf("Edad: %d\n", age);
    printf("Precio: %.2f\n", price);
    printf("Nota: %c\n", grade);
    return 0;
}

Fíjate en los especificadores de formato: %d para int, %f para double, %c para char. printf no inspecciona los valores que le dan: se fía de tu cadena de formato, así que un desajuste imprime disparates en lugar de dar un error.

Asignación después de la declaración

Una vez que una variable existe, la cambias con =:

#include <stdio.h>

int main(void) {
    int score;      /* declarada, valor desconocido */

    score = 0;      /* asignacion */
    printf("Inicio: %d\n", score);

    score = 85;     /* asignar otra vez: el valor viejo se fue */
    printf("Medio:  %d\n", score);

    score = score + 10;   /* leer el valor viejo, guardar el nuevo */
    printf("Final:  %d\n", score);
    return 0;
}

En C, = es asignación, no igualdad. score = score + 10 se lee como "toma lo que hay en score, súmale 10 y vuelve a poner el resultado en score". El operador de comparación es ==, y confundirlos es un error tan común que tiene su propia sección en la página de booleanos.

El atajo score += 10 hace lo mismo con menos caracteres; los operadores de asignación compuesta cubren toda la aritmética.

La trampa de la variable sin inicializar

Este es con diferencia el error de principiante más común en C, y no produce ningún error del compilador:

#include <stdio.h>

int main(void) {
    int total;      /* nunca se le dio un valor */

    for (int i = 1; i <= 5; i++) {
        total += i; /* leyendo total antes de que tenga un valor */
    }

    printf("Total: %d\n", total);
    return 0;
}

Ejecútalo. Puede que veas 15, que es la respuesta correcta. Puede que veas un número aleatorio enorme. Puede que veas algo distinto en una segunda ejecución o en otra máquina. Todos esos son comportamientos "correctos", porque leer una variable local sin inicializar es comportamiento indefinido: el estándar de C no impone ningún requisito sobre lo que pasa.

A diferencia de muchos lenguajes, C no pone tus locales a cero. Una variable local es un trozo de la pila, y la pila está llena de restos de llamadas a funciones anteriores. A veces esos restos resultan ser ceros, que es lo que hace tan peligroso este error: a menudo funciona en las pruebas y falla en producción.

La solución es un carácter:

#include <stdio.h>

int main(void) {
    int total = 0;      /* inicializada */

    for (int i = 1; i <= 5; i++) {
        total += i;
    }

    printf("Total: %d\n", total);
    return 0;
}

Hazlo un hábito: inicializa cada variable en el punto de su declaración. Si genuinamente no tienes todavía un valor sensato, 0 o NULL son mejores que basura. Y compila con -Wall, que detecta la mayoría de los casos:

warning: 'total' is used uninitialized in this function

Las variables globales y static son la excepción: esas sí se inicializan a cero automáticamente. Apoyarse en eso está bien, pero escribir = 0 de todas formas documenta tu intención.

Declarar varias a la vez

Las variables del mismo tipo pueden compartir una declaración, con o sin inicializadores:

#include <stdio.h>

int main(void) {
    int x = 1, y = 2, z = 3;
    double width = 4.5, height;   /* height queda sin inicializar */

    height = 2.0;
    printf("%d %d %d\n", x, y, z);
    printf("area: %.2f\n", width * height);
    return 0;
}

Esto es legal y común para valores muy relacionados como x, y, z. También es donde vive una lectura errónea clásica:

int a = 0, b = 0, c = 0;   /* las tres valen 0 */
int d, e, f = 0;           /* solo f vale 0: d y e son basura */

El inicializador se adjunta a un nombre, no a la línea. Cuando los valores difieren en significado, dale a cada uno su propia línea: se lee mejor y produce mejores diferencias en el control de versiones.

Declarar punteros en una línea tiene la misma trampa en una forma más aguda:

int *p, q;   /* p es un puntero a int; q es un int corriente */

El * se asocia al nombre, no al tipo. Declara los punteros uno por línea.

Reglas y convenciones de nombrado

Las reglas del compilador:

• Solo letras, dígitos y guiones bajos.
• No puede empezar por un dígito: total2 está bien, 2total no.
• No puede ser una palabra clave de C: ninguna variable llamada int, return, for o double.
• Distingue mayúsculas: count, Count y COUNT son tres variables distintas.
• Los nombres que empiezan por guion bajo, o que contienen un doble guion bajo, están reservados para la implementación. No los crees.

int itemCount;       /* legal */
int item_count;      /* legal: el estilo habitual de C */
int _count;          /* legal pero reservado: evitalo */
int item-count;      /* error: '-' es el operador de resta */
int 3rd_place;       /* error: empieza por un digito */
int float;           /* error: palabra clave */

Las convenciones que sigue la mayoría del código C: snake_case para variables y funciones, MAYUSCULAS para las constantes de macro, y nombres que digan qué significa el valor en lugar de qué tipo es. elapsed_ms le gana a t; customer_count le gana a n2.

Los nombres cortos siguen estando bien donde el ámbito es diminuto: i como contador de bucle se entiende universalmente, y nadie quiere for (int indice_de_iteracion_del_bucle = 0; ...).

Dónde vive una variable

Dónde declaras una variable determina quién puede verla y cuánto dura. Eso es el ámbito, y la versión corta es:

#include <stdio.h>

int shared = 100;       /* global: visible para todas las funciones de este archivo */

void show(void) {
    printf("show ve shared = %d\n", shared);
}

int main(void) {
    int local = 5;      /* local de main */

    {
        int inner = 7;  /* local solo de este bloque */
        printf("inner = %d, local = %d\n", inner, local);
    }
    /* inner ya no existe aqui */

    show();
    printf("main ve local = %d\n", local);
    return 0;
}

Una variable es visible desde su declaración hasta la llave de cierre del bloque que la contiene. Las globales viven durante todo el programa y son visibles en todas partes, lo que suena cómodo y es por lo que causan problemas: cualquier función puede cambiar una, así que averiguar quién lo hizo se convierte en una búsqueda por todo el archivo. Prefiere las locales y pasa los valores a las funciones como parámetros.

Declarar en cualquier parte (C99 y posteriores)

En el C89 original, toda declaración tenía que ir antes de cualquier sentencia del bloque:

int main(void) {
    int i, sum = 0;      /* todas las declaraciones primero */
    printf("Empezando\n");
    for (i = 0; i < 10; i++) { sum += i; }
    return 0;
}

Desde C99 puedes declarar donde necesites el valor por primera vez, incluido dentro del encabezado del for:

#include <stdio.h>

int main(void) {
    printf("Empezando\n");

    int sum = 0;                          /* declarada donde hace falta */
    for (int i = 0; i < 10; i++) {        /* i esta limitada al bucle */
        sum += i;
    }

    printf("Suma: %d\n", sum);
    return 0;
}

Este es mejor estilo: la declaración queda junto a su primer uso, e i no puede filtrarse al resto de la función. Compila con -std=c17 (o cualquier configuración de C99 en adelante) y funciona en todas partes.