C Academy · Lección

Constantes #define

Use constantes del preprocesador

Constantes #define es una lección gratuita de C Academy en CoddyKit. Esta es la lección 4 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.

Qué hace #define

#define es una directiva del preprocesador que crea una macro: un nombre que el preprocesador sustituye por texto antes de la compilación.

Se usa habitualmente para dar un nombre legible a un valor fijo, como el tamaño de un búfer o un límite.

#define MAX_LEN 256

Sustitución de texto

Una macro es una sustitución de texto pura. Donde aparezca MAX_LEN, el preprocesador escribe 256 en su lugar.

No hay tipo ni memoria asignada; esto ocurre antes de que el compilador llegue siquiera a ver el código.

#include <stdio.h>
#define MAX_LEN 256
int main(void) {
    printf("%d\n", MAX_LEN);
    return 0;
}

Sin punto y coma

Un error habitual es terminar un #define con un punto y coma.

El punto y coma pasa a formar parte del texto de sustitución y puede provocar errores confusos. No lo incluya.

#define PI 3.14159     /* correct */
#define BAD 10;        /* wrong: semicolon is substituted too */

Definición de una constante de tipo float

Las macros funcionan con cualquier literal, incluidos los valores de coma flotante.

Aquí PI se sustituye en la fórmula del área cada vez que se utiliza.

#include <stdio.h>
#define PI 3.14159
int main(void) {
    double r = 2.0;
    printf("%.2f\n", PI * r * r);
    return 0;
}

Macros para tamaños de arrays

Las macros se usan a menudo para establecer el tamaño de los arrays, porque el valor debe conocerse en tiempo de compilación.

Usar un nombre mantiene el tamaño en un solo lugar y facilita su modificación.

#include <stdio.h>
#define SIZE 5
int main(void) {
    int data[SIZE] = {1, 2, 3, 4, 5};
    printf("%d\n", data[SIZE - 1]);
    return 0;
}

Ponga siempre expresiones entre paréntesis

Si una macro se expande a una expresión, escríbala entre paréntesis.

Sin paréntesis, la precedencia de operadores puede cambiar el significado cuando la macro se usa dentro de una expresión más grande.

#define WIDTH (4 + 2)   /* good */
#define BADW 4 + 2       /* risky: 10 * BADW becomes 10*4+2 */

Por qué importan los paréntesis

Este programa muestra la diferencia. Con paréntesis, WIDTH se multiplica como un todo; sin ellos, solo se multiplica una parte.

La versión segura imprime 60; la expansión no segura produciría un cálculo diferente.

#include <stdio.h>
#define WIDTH (4 + 2)
int main(void) {
    printf("%d\n", 10 * WIDTH);
    return 0;
}

Macros de cadenas

Las macros también pueden representar literales de cadena, lo que resulta práctico para mensajes fijos o nombres de versiones.

El texto se sustituye exactamente, incluidas las comillas.

#include <stdio.h>
#define APP_NAME "CoddyKit"
int main(void) {
    printf("Welcome to %s\n", APP_NAME);
    return 0;
}

#define frente a const

Una macro no tiene tipo ni dirección; una variable const tiene ambos y respeta el ámbito.

Prefiera const cuando necesite seguridad de tipos y visibilidad durante la depuración. Use #define para constantes de tiempo de compilación, como los tamaños de arrays.

#define M_SIZE 10
const int c_size = 10;

Eliminar definiciones y protecciones

Puede eliminar una macro con #undef. Las macros también permiten crear protecciones de cabecera que evitan la inclusión doble.

Este ejemplo muestra el patrón clásico de protección utilizado al principio de los archivos de cabecera.

#ifndef CONFIG_H
#define CONFIG_H
/* header contents here */
#endif

Convención de nombres

Por convención histórica, los nombres de las macros se escriben en MAYÚSCULAS_CON_GUIONES_BAJOS.

Esto las identifica visualmente como constantes del preprocesador y ayuda a evitar conflictos con los nombres de variables normales.

#include <stdio.h>
#define BUFFER_SIZE 1024
int main(void) {
    printf("%d\n", BUFFER_SIZE);
    return 0;
}

Comprobación rápida

Ponga a prueba su comprensión de las macros.

Resumen

#define crea macros que el preprocesador sustituye como texto, sin tipo, sin punto y coma y sin memoria.

Ponga las expresiones entre paréntesis y prefiera const para los valores con seguridad de tipos; reserve las macros para necesidades de tiempo de compilación, como tamaños de arrays y protecciones de cabecera.

Preguntas frecuentes

¿La lección «Constantes #define» es gratis?

Sí — el texto completo de «Constantes #define» 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 «Constantes #define»?

Use constantes del preprocesador 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 4 de 4.

¿Cuánto tiempo toma la lección «Constantes #define»?

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