Constantes en C: const, #define y enum

Una constante es un valor con un nombre y la promesa de que no va a cambiar. C te da tres mecanismos para eso, y por dentro son cosas genuinamente distintas: uno es una variable, otro es sustitución de texto y otro es un tipo entero.

Por qué nombrar un valor

Compara estas dos líneas:

double area = 3.14159 * r * r;
double area = PI * r * r;

La segunda es mejor por tres razones que aparecen todas más adelante. Dice qué significa el número. Aparece en exactamente un lugar, así que cambiar la precisión es una sola edición en vez de una búsqueda. Y un error de tipeo en PI es un error de compilación, mientras que un error de tipeo en 3.14195 es una respuesta equivocada.

A los números sin nombre esparcidos por el código se les llama números mágicos, y eliminarlos es una de las mejoras más baratas que puedes hacerle a un programa en C.

const

La palabra clave const marca una variable como de solo lectura:

#include <stdio.h>

int main(void) {
    const double PI = 3.14159265358979;
    const int MAX_USERS = 100;

    double r = 2.0;
    printf("Area de r=%.1f: %.4f\n", r, PI * r * r);
    printf("Capacidad: %d usuarios\n", MAX_USERS);

    /* PI = 3.0;  <- descomenta esta línea y el programa no compilará */
    return 0;
}

Descomenta la asignación y el compilador se niega: assignment of read-only variable 'PI'. Ese error en tiempo de construcción es justamente el objetivo.

Una variable const es una variable real. Tiene un tipo, así que el compilador verifica cómo la usas. Respeta el alcance, así que una const dentro de una función no se escapa. Tiene una dirección, así que puedes tomar un puntero a ella. Y un depurador puede mostrarte su nombre y su valor.

Una const debe inicializarse en el punto de la declaración: no hay una segunda oportunidad.

const int limit;       /* error (o basura para siempre): nada puede asignarle un valor después */
const int limit = 50;  /* correcto */

#define

La alternativa del preprocesador es una macro:

#include <stdio.h>

#define PI 3.14159265358979
#define MAX_USERS 100
#define GREETING "Bienvenido al sistema"

int main(void) {
    double r = 2.0;
    printf("%s\n", GREETING);
    printf("Area de r=%.1f: %.4f\n", r, PI * r * r);
    printf("Capacidad: %d usuarios\n", MAX_USERS);
    return 0;
}

Esto no es una variable. Antes de que corra el compilador, el preprocesador reemplaza cada aparición de PI en el código fuente por los caracteres 3.14159265358979. El compilador nunca ve el nombre: por eso exactamente un #define no tiene tipo y no puede aparecer en un depurador.

Fíjate que no hay punto y coma ni =. Una macro es texto crudo, así que este error común:

#define MAX_USERS 100;        /* nota el punto y coma */

int limit = MAX_USERS + 1;    /* se expande a: int limit = 100; + 1;  -> error */

produce un error en una línea que no se parece en nada a la definición. La convención de nombrar las macros en mayúsculas existe precisamente para que quien lee sepa que está ocurriendo una sustitución.

Las macros se escriben por convención en MAYUSCULAS; las variables const suelen seguir la misma regla cuando representan la misma idea.

Constantes de enum

La tercera forma te da un conjunto de enteros con nombre:

#include <stdio.h>

enum { MAX_USERS = 100, BUFFER_SIZE = 256 };

enum Weekday { MON, TUE, WED, THU, FRI };

int main(void) {
    char buffer[BUFFER_SIZE];   /* una constante genuina de tiempo de compilación */

    printf("el buffer guarda %zu bytes\n", sizeof(buffer));
    printf("MAX_USERS = %d\n", MAX_USERS);

    enum Weekday today = WED;
    printf("MON=%d TUE=%d WED=%d, hoy=%d\n", MON, TUE, WED, today);
    return 0;
}

Los valores empiezan en 0 y aumentan de uno en uno a menos que los asignes, así que MON es 0 y FRI es 4. Un enum { ... } anónimo es un modismo común para constantes enteras simples.

Las constantes de enum tienen una ventaja real sobre ambas alternativas: son constantes enteras de tiempo de compilación que el compilador entiende, y son visibles para el depurador. La historia completa está en enums en C.

Cuál usar

El valor por defecto debería ser const. Recurre a #define cuando el valor tenga que existir antes de la compilación, y a enum cuando necesites un entero de tiempo de compilación o un grupo con nombre.

El lugar donde esto realmente muerde es en los tamaños de arrays:

#include <stdio.h>

#define DEFINED_SIZE 5
enum { ENUM_SIZE = 5 };

int global_a[DEFINED_SIZE];   /* bien */
int global_b[ENUM_SIZE];      /* bien */

int main(void) {
    const int const_size = 5;
    int local[const_size];    /* array de longitud variable de C99: aquí funciona... */

    for (int i = 0; i < const_size; i++) local[i] = i * i;
    printf("local[4] = %d\n", local[4]);
    printf("globales: %zu %zu\n", sizeof(global_a), sizeof(global_b));
    return 0;
}

Un const int en C es una variable de solo lectura, no una expresión constante de tiempo de compilación. Dentro de una función, C99 acepta int local[const_size] convirtiéndolo en un array de longitud variable; a nivel de archivo, dentro de un struct o como etiqueta case se rechaza de plano. enum y #define funcionan en todas partes.

(Esta es una de las diferencias reales con C++, donde const int sí es una expresión constante. El código que se mueve entre los dos lenguajes tropieza con esto.)

const con punteros

const y los punteros se combinan de tres maneras, y los significados no son intercambiables. Lee la declaración desde el nombre hacia afuera:

const char *p;          /* p apunta a chars que no deben modificarse */
char * const q;         /* q mismo no puede reapuntarse; los chars sí pueden cambiar */
const char * const r;   /* ni el puntero ni los chars pueden cambiar */

#include <stdio.h>

int main(void) {
    char text[] = "hola";

    const char *p = text;
    /* *p = 'H';  <- error: los datos son const a través de p */
    p = "mundo";  /* pero reapuntar p está bien */
    printf("p ahora apunta a: %s\n", p);

    char * const q = text;
    q[0] = 'H';   /* modificar los datos a través de q está bien */
    /* q = "mundo";  <- error: q mismo es const */
    printf("text ahora es: %s\n", text);
    return 0;
}

La forma const char * es la que más vas a escribir, porque es el tipo correcto para un parámetro de función que lee una cadena sin cambiarla:

#include <stdio.h>

/* El const le promete a quien llama: esta función no modificará tu cadena. */
size_t count_vowels(const char *s) {
    size_t n = 0;
    for (size_t i = 0; s[i] != '\0'; i++) {
        char c = s[i];
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') n++;
    }
    return n;
}

int main(void) {
    printf("vocales en \"programming\": %zu\n", count_vowels("programming"));
    return 0;
}

Agregar const a un parámetro de solo lectura no cuesta nada y documenta el contrato de una forma que el compilador hace cumplir. Vale la pena hacerlo en todas partes.

Los literales de cadena son efectivamente const

Una trampa sutil que const existe para atrapar:

char *s = "hola";    /* C legal, pero s apunta a memoria de solo lectura */
s[0] = 'H';          /* comportamiento indefinido: normalmente un crash */

Los literales de cadena viven en una sección de solo lectura del ejecutable. Escribir a través de ese puntero típicamente provoca un segfault. Declarar el puntero como const char *s = "hola"; hace que el compilador rechace la asignación en lugar de dejar que falle en tiempo de ejecución.

Si necesitas una cadena modificable, cópiala a un array:

#include <stdio.h>

int main(void) {
    const char *literal = "hola";    /* solo lectura, no se puede modificar */
    char copy[] = "hola";            /* un array: una copia privada y modificable */

    copy[0] = 'H';
    printf("literal: %s\n", literal);
    printf("copia:   %s\n", copy);
    return 0;
}