Cursos Empresas Blog Live Conf Eventos Precios

0:007:55

Recursos

Resumen

¿Cómo utilizar la directiva define en C?

El lenguaje C nos ofrece diversas herramientas para facilitarnos la programación, y una de ellas es la directiva de preprocesador define. Esta permite declarar constantes de una forma eficiente y práctica, especialmente útil cuando se trabaja con valores que no cambian durante la ejecución del programa.

¿Cuáles son las buenas prácticas al usar define?

Nombres en mayúsculas: Es una buena práctica escribir las constantes en mayúsculas para diferenciarlas de las variables comunes.
Definir al inicio del archivo: Colocar todas tus constantes definidas al inicio del archivo, así cualquier modificación se hace solo en un sitio.

Ejemplo de implementación de constantes

Vamos a ver un ejemplo práctico donde utilizamos constantes para representar el costo de una pizza, entre otras cosas:

#include <stdio.h>

#define PIZZA_COST 1.5
#define NEW_LINE '\n'

int main() {
    float number_of_slices = 1;
    float costo_pizzas = PIZZA_COST * number_of_slices;

    printf("Total bill: %f%c", costo_pizzas, NEW_LINE);

    return 0;
}

¿Cuándo utilizar define o const?

define: Ideal para valores que son configurables y repetidos en distintos puntos del código, pero que no cambian durante la ejecución. Al definirlos al inicio, se centraliza el control de los mismos, evitando la necesidad de modificar cada uso individualmente.
const: Útil para definir constantes dentro de una función cuando el valor no necesita ser accesible de forma global, proporcionando así un orden y encapsulamiento más controlado en el código.

Beneficios de centralizar las definiciones con define

Usar define al inicio del código proporciona ventajas significativas:

Centralización y claridad: Al modificar un valor, solo necesitas cambiarlo una vez, y todo tu código se actualizará automáticamente.
Eficiencia: Evita búsquedas innecesarias para modificar valores múltiplemente definidos en el código.
Mantenimiento: Si un valor aparece muchas veces en el código, no tendrás que buscar y reemplazar cada instancia individualmente.

En resumen, la utilización de define y const en C no solo aumenta la eficiencia del programador, sino que también mejora la legibilidad y mantenibilidad del código. Recuerda siempre poner en práctica estas técnicas para lograr un desarrollo más organizado y efectivo. ¡Continúa con tu aprendizaje y conviértete en un mejor desarrollador C!

Uso de "define" y "const" para constantes en C

Curso de Introducción a C

Clase 15 / 16

Ver clases

Uso de "define" y "const" para constantes en C

Curso de Introducción a C

Clase 15 de 16

Clase 15 / 16

Uso de "define" y "const" para constantes en C

Curso de Introducción a C

Clase 15 / 16

Ver clases

#include <stdio.h> #define PIZZA_COST 1.5 #define NEW_LINE '\n' int main() { float number_of_slices = 1; float costo_pizzas = PIZZA_COST * number_of_slices; printf("Total bill: %f%c", costo_pizzas, NEW_LINE); return 0; }

Comentarios

Alejandro Urrea Giraldo#1406904

Para aquellos que quedaron con la duda de qué es una directiva de preprocesador, les comparto la explicación:

Una directiva de preprocesador es una instrucción que recibe el compilador y le indica que hay ciertas acciones a realizar antes de iniciar a compilar el programa. Se insertan al principio de cada programa, y se identifican por estar precedidas por el caracter # (Hastag)

Una de las más conocidas es la directiva include, que le dice al compilador que debe incluir una librearía (código previamente escrito, con alguna funcionalidad extra que puede ser usada de manera general en muchos programas) y hacerla parte del código actual.

Otras directivas de prerpocesador son #ifdef, #ifndef, #else, #elif y #endif las cuales sirven como condiciones para evitar errores, al definir varias veces las mismas variables.

Espero les sirva!

Youssef Abarca#1634166

También se puede usar define para reemplazar nombres de funciones.

#include <stdio.h>
#include <stdlib.h>

#define PIZZACOST 1.5
#define p printf

const char NEWLINE = '\n';

int main (int argc, const char* argv[])
{
    float costPizza;
    float numberOfSlices = 3;

    costPizza = PIZZACOST * numberOfSlices;

    p("%.2f", costPizza);
    p("%c", NEWLINE);

    return 0;
}

Brandon Argel Verdeja Domínguez#2123402

Si quieren poner nada más "n" decimales pueden poner: Entre el signo % y el tipo de variable se pone un punto y el número de decimales que quieres por ejemplo: %.2f Con eso si el valor era 4.5000000 ahora solo mostrará 4.50

#include <stdio.h>
#include <stdlib.h>

#define PIZZACOST 1.5
#define p printf

const char NEWLINE = '\n';

int main (int argc, const char* argv[])
{
    float costPizza;
    float numberOfSlices = 3;

    costPizza = PIZZACOST * numberOfSlices;

    p("%.2f", costPizza);
    p("%c", NEWLINE);

    return 0;
}

#include <stdio.h>

#define PIZZACOST 1.5
const NEWLINE = '\n';

int main()
{
    float costPizzas;
    float numberofslices = 3;
    costPizzas = PIZZACOST * numberofslices;

    printf("Total bill: %c %f",NEWLINE, costPizzas);
}```

// const int COSTHOTDOG = 100;
// const float BILL = 100.58;
// const char NEWLINE = '\n'

#include <stdio.h>

#define PIZZACOST 1.5
const char NEWLINE = '\n' ;

int main(){
    float costPizza;
    float numberOfSlices = 3;
    costPizza = PIZZACOST * numberOfSlices;

    printf("Total bill: %c %f", NEWLINE, costPizza);
}

printf("\n=== INICIO DE SIMULACION DEL CPU ===\n");
printf("Programa en memoria: SUMAR %d + %d\n\n",
       ram->data[2], ram->data[3]);

while (running && cycle <= 20) {

    // ── FETCH: traer instruccion de memoria ──
    cpu->MAR = cpu->PC;
    cpu->MDR = ram->data[cpu->MAR];
    cpu->IR  = cpu->MDR;
    cpu->PC++;
    print_state(cpu, ram, cycle, "FETCH",
                "Instruccion leida de RAM al IR");

    // ── DECODE + EXECUTE ──
    int opcode = cpu->IR;

    if (opcode == 10) {
        // LOAD R0 ← RAM[2]
        cpu->MAR    = 2;
        cpu->MDR    = ram->data[cpu->MAR];
        cpu->reg[0] = cpu->MDR;
        print_state(cpu, ram, cycle, "EXECUTE",
                    "LOAD R0 <- RAM[2] (valor A)");
    }
    else if (opcode == 11) {
        // LOAD R1 ← RAM[3]
        cpu->MAR    = 3;
        cpu->MDR    = ram->data[cpu->MAR];
        cpu->reg[1] = cpu->MDR;
        print_state(cpu, ram, cycle, "EXECUTE",
                    "LOAD R1 <- RAM[3] (valor B)");
    }
    else if (opcode == 20) {
        // ADD R0 + R1 → ALU → R2
        cpu->ALU_result = cpu->reg[0] + cpu->reg[1];
        cpu->reg[2]     = cpu->ALU_result;
        print_state(cpu, ram, cycle, "EXECUTE",
                    "ALU: R2 = R0 + R1");
    }
    else if (opcode == 30) {
        // STORE R2 → RAM[5]
        ram->data[5] = cpu->reg[2];
        print_state(cpu, ram, cycle, "EXECUTE",
                    "STORE R2 -> RAM[5]");
    }
    else if (opcode == 40) {
        // PRINT resultado
        printf("\n>>> RESULTADO FINAL: %d + %d = %d <<<\n",
               ram->data[2], ram->data[3], cpu->reg[2]);
        print_state(cpu, ram, cycle, "EXECUTE",
                    "PRINT resultado en pantalla");
    }
    else if (opcode == 99) {
        // HALT
        print_state(cpu, ram, cycle, "HALT",
                    "CPU detenido correctamente");
        running = 0;
    }

    cycle++;
}

printf("\n=== FIN DE SIMULACION ===\n");

Comentarios

Alejandro Urrea Giraldo#1406904

Para aquellos que quedaron con la duda de qué es una directiva de preprocesador, les comparto la explicación:

Otras directivas de prerpocesador son #ifdef, #ifndef, #else, #elif y #endif las cuales sirven como condiciones para evitar errores, al definir varias veces las mismas variables.

Espero les sirva!

Youssef Abarca#1634166

También se puede usar define para reemplazar nombres de funciones.

#include <stdio.h>
#include <stdlib.h>

#define PIZZACOST 1.5
#define p printf

const char NEWLINE = '\n';

int main (int argc, const char* argv[])
{
    float costPizza;
    float numberOfSlices = 3;

    costPizza = PIZZACOST * numberOfSlices;

    p("%.2f", costPizza);
    p("%c", NEWLINE);

    return 0;
}

Brandon Argel Verdeja Domínguez#2123402

#include <stdio.h>
#include <stdlib.h>

#define PIZZACOST 1.5
#define p printf

const char NEWLINE = '\n';

int main (int argc, const char* argv[])
{
    float costPizza;
    float numberOfSlices = 3;

    costPizza = PIZZACOST * numberOfSlices;

    p("%.2f", costPizza);
    p("%c", NEWLINE);

    return 0;
}

#include <stdio.h>

#define PIZZACOST 1.5
const NEWLINE = '\n';

int main()
{
    float costPizzas;
    float numberofslices = 3;
    costPizzas = PIZZACOST * numberofslices;

    printf("Total bill: %c %f",NEWLINE, costPizzas);
}```

// const int COSTHOTDOG = 100;
// const float BILL = 100.58;
// const char NEWLINE = '\n'

#include <stdio.h>

#define PIZZACOST 1.5
const char NEWLINE = '\n' ;

int main(){
    float costPizza;
    float numberOfSlices = 3;
    costPizza = PIZZACOST * numberOfSlices;

    printf("Total bill: %c %f", NEWLINE, costPizza);
}

printf("\n=== INICIO DE SIMULACION DEL CPU ===\n");
printf("Programa en memoria: SUMAR %d + %d\n\n",
       ram->data[2], ram->data[3]);

while (running && cycle <= 20) {

    // ── FETCH: traer instruccion de memoria ──
    cpu->MAR = cpu->PC;
    cpu->MDR = ram->data[cpu->MAR];
    cpu->IR  = cpu->MDR;
    cpu->PC++;
    print_state(cpu, ram, cycle, "FETCH",
                "Instruccion leida de RAM al IR");

    // ── DECODE + EXECUTE ──
    int opcode = cpu->IR;

    if (opcode == 10) {
        // LOAD R0 ← RAM[2]
        cpu->MAR    = 2;
        cpu->MDR    = ram->data[cpu->MAR];
        cpu->reg[0] = cpu->MDR;
        print_state(cpu, ram, cycle, "EXECUTE",
                    "LOAD R0 <- RAM[2] (valor A)");
    }
    else if (opcode == 11) {
        // LOAD R1 ← RAM[3]
        cpu->MAR    = 3;
        cpu->MDR    = ram->data[cpu->MAR];
        cpu->reg[1] = cpu->MDR;
        print_state(cpu, ram, cycle, "EXECUTE",
                    "LOAD R1 <- RAM[3] (valor B)");
    }
    else if (opcode == 20) {
        // ADD R0 + R1 → ALU → R2
        cpu->ALU_result = cpu->reg[0] + cpu->reg[1];
        cpu->reg[2]     = cpu->ALU_result;
        print_state(cpu, ram, cycle, "EXECUTE",
                    "ALU: R2 = R0 + R1");
    }
    else if (opcode == 30) {
        // STORE R2 → RAM[5]
        ram->data[5] = cpu->reg[2];
        print_state(cpu, ram, cycle, "EXECUTE",
                    "STORE R2 -> RAM[5]");
    }
    else if (opcode == 40) {
        // PRINT resultado
        printf("\n>>> RESULTADO FINAL: %d + %d = %d <<<\n",
               ram->data[2], ram->data[3], cpu->reg[2]);
        print_state(cpu, ram, cycle, "EXECUTE",
                    "PRINT resultado en pantalla");
    }
    else if (opcode == 99) {
        // HALT
        print_state(cpu, ram, cycle, "HALT",
                    "CPU detenido correctamente");
        running = 0;
    }

    cycle++;
}

printf("\n=== FIN DE SIMULACION ===\n");

Julian Moliniva#4820296

La directiva #define es una herramienta útil en el lenguaje de programación C que permite asignar un nombre a un valor o expresión constante.

La sintaxis básica de la directiva es la siguiente:

#define nombre valor

Donde 'nombre' es el nombre que se asigna y 'valor' es el valor o expresión constante que se le asigna. Una vez que se define una directiva, el preprocesador reemplaza todas las apariciones de 'nombre' con 'valor' en todo el código.

Por ejemplo, si se define la siguiente directiva:

#define PI 3.1416

Luego se puede usar el nombre 'PI' en lugar del valor '3.1416' en todo el código.

La directiva #define también se puede utilizar para definir macros, que son bloques de código que se pueden llamar utilizando el nombre que se le asigna. En este caso, la sintaxis básica es la siguiente:

#define nombre(parametros) bloque de código

Donde 'nombre' es el nombre de la macro, 'parametros' son los parámetros que se pueden pasar a la macro y 'bloque de código' es el código que se ejecuta cuando se llama a la macro.

Por ejemplo, se puede definir una macro para calcular el área de un círculo de la siguiente manera:

#define AREA_CIRCULO(radio) (PI * radio * radio)

Luego se puede llamar a la macro utilizando el nombre 'AREA_CIRCULO' y pasando el radio como parámetro:

float area = AREA_CIRCULO(2.5);

En este caso, la macro se expandiría a:

float area = (3.1416 * 2.5 * 2.5);

Y el resultado sería asignado a la variable 'area'.
En resumen, la directiva #define es una herramienta poderosa que permite asignar nombres a valores o expresiones constantes y definir macros para simplificar el código. Es importante tener en cuenta que el preprocesador reemplaza todas las apariciones de 'nombre' con 'valor', por lo que es importante elegir nombres significativos y evitar posibles conflictos de nombres.

Comentarios (45)45 comentarios

Alejandro Urrea Giraldo

Hace 6 años

Jean Nuñez

Gracias esto me ayuda un monton

Rafael Pardo Rodriguez

Al simbolo # se le puede decir, hash, numeral, almohadilla.

Youssef Abarca

Andrés Fernando Cortés Pinzón

Muchas gracias por el dato, no tenia ni idea.

Juan Andrés Cabrera Mendoza

oh muchas graciias

Brandon Argel Verdeja Domínguez

Uriel Garcia

LAS CONSTANTES SE DECLARAN EN MAYUSCULAS

Moisés Manuel Morín Hevia

Directivas.

Una instrucción que recibe el compilador y le 
indica que hay ciertas acciones a realizar antes de iniciar a compilar el programa.

Daniel Enrique Astudillo Guzmán

Asi es, declarar constantes globales ayuda a la optimización de código y menos tiempo de debugging :)

Alvaro Iván Monges Barrios

PERO la declaración de variables globales en C es una práctica malísima y sólo debe utilizarse en casos muy muy muy muy muy particulares, como por ejemplo el manejo de "señales", al llamarse funciones que no pueden recibir parámetros es 100% necesario utilizar variables globales. Te invito a investigar manejo de señales en C, es algo genial. Saludos.

Julian Moliniva

Hace 3 años

Carlos Lefin Henriquez

Cual es la principal diferencia entre una Constante y un Define?

Miguel Angel Velazquez Romero

La directiva #define es una directiva de preprocesador; el preprocesador reemplaza esas macros por su cuerpo antes de que el compilador lo vea. Piense en ello como una búsqueda y reemplazo automático de su código fuente.

Una declaración de variable const declara una variable real en el lenguaje, que puedes usar ... bueno, como una variable real: toma su dirección, pásala, usa cast, conviértela, etc.

Sobre el endimiento: tal vez esté pensando que evitar la declaración de una variable ahorra tiempo y espacio, pero con cualquier nivel de optimización del compilador sensible no habrá diferencia, ya que los valores constantes ya se sustituyen y se pliegan en el momento de la compilación. Pero obtienes la gran ventaja de verificar el tipo y hacer que el depurador conozca tu código, por lo que realmente no hay razón para no usar variables const.

Irving Juárez

La directiva preprocesador define puede incluso hacer operaciones, tales como sumas o restas, en cambio las consts no pueden hacer eso, como en el siguiente ejemplo:

#include <stdio.h>

#define MAX (a > b) ? a : b

int main(){
	int a = 1, b = 2;
	printf("El numero mayor es: %d \n", SUM a);

return 0;
}

Esto es un ejemplo mas complejo pero es una buena manera de diferenciarlo

Luis Fernando Baldovino De Castro

Hace 4 años

#define y const global, tienen un funcionamiento interno diferente. En un const global la información se guarda en un espacio de memoria de solo lectura y es accesible desde cualquier parte del código. Cuando hacemos uso del #define lo que ocurre realmente es que antes de compilar, el preprocesador reemplaza en el código todas las ocurrencias del nombre que definimos por su valor, es decir, esos valores pasan a ser parte del programa y no van a ocupar memoria RAM

Miguel Angel Lozano Alvarez

Mi codigo

Gracias, buen aporte

Gabriel Obregón

Hace un año

📝define en C

🔹 ¿Qué es define?

📌 Directiva del preprocesador en C

📌 Declara constantes fijas (no cambian en ejecución)

📌 Se escribe al inicio del archivo → centraliza valores

✅ Buenas prácticas

🔠 MAYÚSCULAS para nombres de constantes 📍 Colocar todas las constantes al inicio del archivo ✏️ Facilita cambios en un solo lugar

💻 Ejemplo práctico

#include <stdio.h>

#define PIZZA_COST 1.5

#define NEW_LINE '\n'

int main() {

float number_of_slices = 1;

float costo_pizzas = PIZZA_COST * number_of_slices;

printf("Total bill: %f%c", costo_pizzas, NEW_LINE);

return 0;

}

👉 Explicación:

🍕 PIZZA_COST = costo de una pizza

↩️ NEW_LINE = salto de línea

🔄 Cambias PIZZA_COST → se actualiza en todo el código

🔄 ¿Cuándo usar define o const?

🔹 define

Valores repetidos en muchas partes
Centralización al inicio del archivo
No cambian en ejecución

🔹 const

Constantes dentro de funciones
Aporta orden y encapsulamiento
Útil si no se necesita acceso global

🌟 Beneficios de define

✨ Centralización y claridad → un solo cambio afecta todo ⚡ Eficiencia → evita modificaciones repetidas 🛠️ Mantenimiento fácil → valores usados muchas veces se actualizan de golpe

Dennis Rubio

Mal

Gilberto A. Guerrero Caballero

Hace 5 años

Me queda una duda con respecto a la inicialización de la constante NEWLINE, en la cual colocan el valor entre comilla simple, en lugar de comilla doble:

const char NEWLINE = '\n';

¿Cuando se debe usar comillas dobles y cuando simples?, ya que vi ciertos ejemplo de variables char inicializadas con comillas dobles y otras con simples como lo es este caso.

Héctor Eduardo López Carballo

Hola!

En ciertos lenguajes de programación es irrelevante qué tipo de comillas usas, en otros necesitas utilizar comillas simples para carácteres y dobles para strings.

Luis Alberto Juarez Corona

#include <stdlib.h>

unsigned int a, b, c;

float f, g, h;

//preprocessor directives siempre que se usa de manera global

#define IVA 0.16

int main(int argc, char const *argv[])

{

float costoPizza = 100;

float pagoFinal=0;

pagoFinal =( costoPizza * IVA )+costoPizza;

printf("El costo de mi pizza es de: %f", pagoFinal);

//strigns literal que se maneja en un arreglo de caracteres

char saludo[] ="Mi nombre es luis juares";

// valores de las constantes

const int edad=23;

// variables

b=4, c=90;

a=b+c;

printf("numero %i \n",a );

printf("Mi edad es de: %i , saludos: %s: ",edad, saludo);

Mauren García

#define Declara valores constantes, cuando usarlo? Va genial para poner todas las definiciones de valores arriba, facilita la redacción de código y las operaciones. Es una buena práctica definir estos valores como #define. SE USA PARA CONSTANTES GLOBALES, si usaremos una constante que no es global, podemos ocupar const.

Jonathan Fernando Santana Quispillo

Donde esta el curso de Introducción de C 2019. Era bueno el curso porque lo quitaron :(. Tenia mas temas y muy importantes. Por favor necesito ese curso.

Sebastian Heredia

Vaya que genial, al parecer el tema del scope funciona en la mayoría de lenguajes y claramente C no fue la excepción :)

César Luis Solano León

¿Hay alguna librería para que cuando vaya a imprimir tenga en cuenta símbolos como ñ?

Alexander Reyes

Te dejo este recursos para que veas alternativas sobre imprimir caracteres UNICODE. Hay varias opciones, pero unas son más adecuadas que otras según el tipo de problema que queremos resolver.

Ernesto Cajar

Hace un día

Si tienes una variable 5000 mil veces repetidas en tu codigo, es una clara demostración de malas practicas . Algo que jamás deberias hacer

Miguel Angel Otero Otero

Hace 5 meses

#include <stdio.h> #include <stdlib.h>

// ─── Constantes ─────────────────────────────────────────────── #define RAM_SIZE 8 #define REG_COUNT 4 #define CLOCK_CYCLES 6

// ─── Estructuras que representan componentes del CPU ────────── typedef struct { int data[RAM_SIZE]; // celdas de memoria } RAM;

typedef struct { int reg[REG_COUNT]; // registros generales: R0, R1, R2, R3 int PC; // Program Counter int IR; // Instruction Register int MAR; // Memory Address Register int MDR; // Memory Data Register int ALU_result; // resultado de la ALU } CPU;

// ─── Inicialización ─────────────────────────────────────────── void init_ram(RAM *ram) { // Simulamos un pequeño programa en memoria: // LOAD R0, dir[2] → opcode 10 // LOAD R1, dir[3] → opcode 11 // ADD R0, R1 → opcode 20 // STORE resultado → opcode 30 // PRINT resultado → opcode 40 // HALT → opcode 99 ram->data[0] = 10; // instruccion: LOAD R0 ram->data[1] = 11; // instruccion: LOAD R1 ram->data[2] = 25; // dato: valor A = 25 ram->data[3] = 17; // dato: valor B = 17 ram->data[4] = 20; // instruccion: ADD ram->data[5] = 30; // instruccion: STORE ram->data[6] = 40; // instruccion: PRINT ram->data[7] = 99; // instruccion: HALT }

void init_cpu(CPU *cpu) { for (int i = 0; i < REG_COUNT; i++) cpu->reg[i] = 0; cpu->PC = 0; cpu->IR = 0; cpu->MAR = 0; cpu->MDR = 0; cpu->ALU_result = 0; }

// ─── Impresión del estado del sistema ───────────────────────── void print_state(CPU *cpu, RAM *ram, int cycle, const char *fase, const char *desc) { printf("\n╔══════════════════════════════════════════════════╗\n"); printf("║ CICLO %d | FASE: %-10s ║\n", cycle, fase); printf("╠══════════════════════════════════════════════════╣\n"); printf("║ DESCRIPCION: %-35s║\n", desc); printf("╠══════════════════════════════════════════════════╣\n"); printf("║ REGISTROS CPU ║\n"); printf("║ PC=%d IR=%d MAR=%d MDR=%d ALU=%d \n", cpu->PC, cpu->IR, cpu->MAR, cpu->MDR, cpu->ALU_result); printf("║ R0=%-4d R1=%-4d R2=%-4d R3=%-4d \n", cpu->reg[0], cpu->reg[1], cpu->reg[2], cpu->reg[3]); printf("╠══════════════════════════════════════════════════╣\n"); printf("║ MEMORIA RAM: "); for (int i = 0; i < RAM_SIZE; i++) printf("[%d:%d] ", i, ram->data[i]); printf("\n"); printf("╚══════════════════════════════════════════════════╝\n"); }

// ─── Ciclo Fetch → Decode → Execute ────────────────────────── void run_cpu(CPU *cpu, RAM *ram) { int cycle = 1; int running = 1;

// ─── Main ───────────────────────────────────────────────────── int main() { RAM ram; CPU cpu;

init_ram(&ram);
init_cpu(&cpu);
run_cpu(&cpu, &ram);

return 0;

Recursos

Resumen

Uso de "define" y "const" para constantes en C

Uso de "define" y "const" para constantes en C

Uso de "define" y "const" para constantes en C

Progreso del curso

Introducción al lenguaje C

Estructura de un programa C

Tipos de Datos en el lenguaje C

Variables en el lenguaje C

Conclusiones

Uso de "define" y "const" para constantes en C

Uso de "define" y "const" para constantes en C

Recursos

Resumen

¿Cómo utilizar la directiva `define` en C?

¿Cuáles son las buenas prácticas al usar `define`?

Ejemplo de implementación de constantes

¿Cuándo utilizar `define` o `const`?

Beneficios de centralizar las definiciones con `define`

Comentarios

Recursos

Resumen

¿Cómo utilizar la directiva `define` en C?

¿Cuáles son las buenas prácticas al usar `define`?

Ejemplo de implementación de constantes

¿Cuándo utilizar `define` o `const`?

Beneficios de centralizar las definiciones con `define`

Comentarios

Resumen

Uso de "define" y "const" para constantes en C

Uso de "define" y "const" para constantes en C

Uso de "define" y "const" para constantes en C

Uso de "define" y "const" para constantes en C

Uso de "define" y "const" para constantes en C

Resumen

¿Cómo utilizar la directiva define en C?

¿Cuáles son las buenas prácticas al usar define?

Ejemplo de implementación de constantes

¿Cuándo utilizar define o const?

Beneficios de centralizar las definiciones con define

Comentarios

Resumen

¿Cómo utilizar la directiva define en C?

¿Cuáles son las buenas prácticas al usar define?

Ejemplo de implementación de constantes

¿Cuándo utilizar define o const?

Beneficios de centralizar las definiciones con define

Comentarios

¿Cómo utilizar la directiva `define` en C?

¿Cuáles son las buenas prácticas al usar `define`?

¿Cuándo utilizar `define` o `const`?

Beneficios de centralizar las definiciones con `define`

¿Cómo utilizar la directiva `define` en C?

¿Cuáles son las buenas prácticas al usar `define`?

¿Cuándo utilizar `define` o `const`?

Beneficios de centralizar las definiciones con `define`