What You Will Learn

Prerequisites

Lectures 1 to 3 on integer, floating, character and string constants. You will also see the idea of “compiling in stages”; we explain it here as needed.

What Are Symbolic Constants in C?

A symbolic constant (also called a named constant) is a name that stands for a fixed value, such as MAX_STUDENTS for 5 or PI for 3.14159265. The value can be numeric, a character or a string. Using names instead of raw numbers, sometimes called removing “magic numbers”, makes code readable, because for (i = 0; i < MAX_STUDENTS; i++) explains itself, and maintainable, because changing the value in one place updates every use.

Defining Symbolic Constants in C with #define

The classic tool is the preprocessor directive #define NAME value. By convention names are upper case with underscores. There is no equals sign and no semicolon at the end. The directive is not a C statement at all; it is an instruction to a text-replacement tool that runs before the compiler sees your code.

#define MAX_STUDENTS 5
#define PI           3.14159265
#define GRADE_PASS   'P'
#define COURSE       "Embedded C"

The compiler never sees the name. Macro names do not appear in your debugger either.

You can watch the preprocessor work with gcc -E. For the program in Example 2 below it prints these final lines:

int main(void)
{
    printf("SQUARE_BAD(2 + 3) = %d\n", 2 + 3 * 2 + 3);
    printf("SQUARE_OK(2 + 3)  = %d\n", ((2 + 3) * (2 + 3)));
    return 0;
}

Because it is plain text substitution, a macro has no type, no memory address and no scope; it simply exists from the line of definition until #undef or the end of the file.

Symbolic Constants in C: The Macro Parentheses Trap

Since the preprocessor pastes text, operator precedence can betray you. If you write #define OFFSET 4+2 and later use OFFSET * 2, the compiler sees 4+2*2, which is 8 and not 12. The fix is a habit: wrap expressions in parentheses, and wrap every macro parameter too.

The intended answer was 25. Parentheses around each x and around the whole body fix it.

const and enum: Typed Alternatives to #define

Modern C offers safer options. A const variable has a real type, a real address, obeys scope rules and appears in the debugger. An enum constant gives you named integers that the compiler treats as true constant expressions. C23 adds constexpr objects, which combine the benefits of both.

Configuring Builds with Symbolic Constants in C

A very practical use of macros is letting the build command choose a value. The pattern is #ifndef NAME followed by a default #define, so a -D flag on the compiler line can override it. Embedded projects use this for board revision, log level, feature switches and clock speed, with no source edits.

Hands-On: Four Programs on Symbolic Constants in C

Example 1: Named constants of every kind

Save this as named_consts.c:

#include <stdio.h>

#define MAX_STUDENTS 5
#define PI           3.14159265
#define GRADE_PASS   'P'
#define COURSE       "Embedded C"

int main(void)
{
    double r = 2.0;
    int total = 0;

    printf("Course : %s, grade code : %c\n", COURSE, GRADE_PASS);
    printf("Area of circle r=%.1f is %.4f\n", r, PI * r * r);

    for (int i = 1; i <= MAX_STUDENTS; i++)
        total += i;
    printf("Sum of 1..%d = %d\n", MAX_STUDENTS, total);
    return 0;
}

Build and run:

$ gcc -Wall -Wextra -std=c11 -o named_consts named_consts.c
$ ./named_consts

Course : Embedded C, grade code : P
Area of circle r=2.0 is 12.5664
Sum of 1..5 = 15

• A single edit to MAX_STUDENTS changes the loop and the printed message together.
• The area is 3.14159265 × 2 × 2 = 12.5664 after %.4f rounding.
• COURSE and GRADE_PASS are replaced by the string and character text before compilation.

Example 2: The square macro bug

Save this as macro_trap.c:

#include <stdio.h>

#define SQUARE_BAD(x) x * x
#define SQUARE_OK(x)  ((x) * (x))

int main(void)
{
    printf("SQUARE_BAD(2 + 3) = %d\n", SQUARE_BAD(2 + 3));
    printf("SQUARE_OK(2 + 3)  = %d\n", SQUARE_OK(2 + 3));
    return 0;
}

Build and run:

$ gcc -Wall -Wextra -std=c11 -o macro_trap macro_trap.c
$ ./macro_trap

SQUARE_BAD(2 + 3) = 11
SQUARE_OK(2 + 3)  = 25

The bad version expands to 2 + 3 * 2 + 3, giving 11. The good version expands to ((2 + 3) * (2 + 3)), giving 25. Even the fixed macro evaluates its argument twice, so SQUARE_OK(i++) would increment twice. For function-like behaviour prefer a static inline function.

Example 3: const, enum and define together

Save this as three_ways.c:

#include <stdio.h>

#define TIMEOUT_MS 250
enum { BUF_SIZE = 8 };
const int retries = 3;

int main(void)
{
    int buf[BUF_SIZE];

    printf("buffer holds %zu ints\n", sizeof(buf) / sizeof(buf[0]));
    printf("worst wait = %d ms\n", TIMEOUT_MS * retries);
    return 0;
}

Build and run:

$ gcc -Wall -Wextra -std=c11 -o three_ways three_ways.c
$ ./three_ways

buffer holds 8 ints
worst wait = 750 ms

• BUF_SIZE is an enum constant, so it can size the array and sizeof(buf) / sizeof(buf[0]) yields 8.
• TIMEOUT_MS is a macro; retries is a const int with an address and a type.
• 250 × 3 gives 750 milliseconds of worst-case waiting.
• Computing the element count with sizeof means you only edit one number if the buffer grows.

Example 4: Overriding a default with -D

Save this as log_level.c:

#include <stdio.h>

#ifndef LOG_LEVEL
#define LOG_LEVEL 1
#endif

int main(void)
{
    printf("LOG_LEVEL = %d\n", LOG_LEVEL);
#if LOG_LEVEL >= 2
    printf("verbose logging is ON\n");
#endif
    return 0;
}

Build and run:

$ gcc -Wall -std=c11 -o log_level log_level.c
$ ./log_level
$ gcc -Wall -std=c11 -DLOG_LEVEL=3 -o log_level log_level.c
$ ./log_level

$ ./log_level
LOG_LEVEL = 1
$ ./log_level
LOG_LEVEL = 3
verbose logging is ON

The first build uses the default LOG_LEVEL of 1, so the verbose line is compiled out entirely: it is not just skipped at run time, it does not exist in the binary. The second build passes -DLOG_LEVEL=3, the #if test succeeds and the extra message appears. This is how production firmware ships with logging off and debug builds turn it on.

Common Mistakes and Troubleshooting

Best Practices, Performance and Security

• One definition, one place. Put project constants in a header so every file sees the same value.
• Prefix names with the module, such as UART_BAUD_RATE, to avoid clashes in big projects.
• Prefer typed options (enum, const, static inline) when you do not need preprocessor features; you get type checking and debugger visibility.
• Performance: macros and enums cost no run-time memory or lookups. A const object may occupy flash, but optimising compilers usually fold its value into the code.
• Security: unsafe macros can hide double evaluation and integer overflow. Keep size-related constants unsigned and wrap them fully in parentheses, for example (64u * 1024u).

Quiz: Symbolic Constants in C

Try each question on paper first. Click a question to reveal the answer.

Interview Questions: Symbolic Constants in C

These come up in embedded and product-company interviews. Answer out loud, then click.

Summary and Key Takeaways

• Symbolic constants replace magic numbers with meaningful names and a single point of change.
• #define is text substitution done by the preprocessor, with no type and no scope.
• Always parenthesise macro bodies and parameters; use inline functions when you can.
• enum and const are typed, scoped, debugger-friendly alternatives.
• #ifndef plus -D lets the build choose values without editing code.
• gcc -E shows exactly what the compiler receives.

Conclusion

Symbolic constants in C are one of the simplest tools that make programs readable and easy to change. You now know three ways to name a value, what the preprocessor does behind the scenes, and how a missing pair of parentheses turns 25 into 11. You also saw how real embedded projects flip behaviour with a single compiler flag.

With all four kinds of constants covered, the final lecture of this chapter introduces variables: named storage that can change, and the rules for declaring and initialising them.

Frequently Asked Questions