Constants in C: const, #define, and enum

A constant is a value with a name and a promise that it will not change. C gives you three mechanisms for that, and they are genuinely different things under the hood - one is a variable, one is text substitution, and one is an integer type.

Why Name a Value at All

Compare these two lines:

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

The second is better for three reasons that all show up later. It says what the number means. It appears in exactly one place, so changing the precision is one edit rather than a search. And a typo in PI is a compile error, where a typo in 3.14195 is a wrong answer.

Unnamed numbers scattered through code are called magic numbers, and removing them is one of the cheapest improvements you can make to a C program.

const

The const keyword marks a variable as read-only:

#include <stdio.h>

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

    double r = 2.0;
    printf("Area of r=%.1f: %.4f\n", r, PI * r * r);
    printf("Capacity: %d users\n", MAX_USERS);

    /* PI = 3.0;  <- uncomment this line and the program will not compile */
    return 0;
}

Uncomment the assignment and the compiler refuses: assignment of read-only variable 'PI'. That error at build time is the whole point.

A const variable is a real variable. It has a type, so the compiler checks how you use it. It obeys scope, so a const inside a function does not leak out. It has an address, so you can take a pointer to it. And a debugger can show you its name and value.

const must be initialized at the point of declaration - there is no second chance:

const int limit;       /* error (or garbage forever): nothing can assign to it later */
const int limit = 50;  /* correct */

#define

The preprocessor alternative is a macro:

#include <stdio.h>

#define PI 3.14159265358979
#define MAX_USERS 100
#define GREETING "Welcome to the system"

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

This is not a variable. Before the compiler runs, the preprocessor replaces every occurrence of PI in the source with the characters 3.14159265358979. The compiler never sees the name at all - which is exactly why a #define has no type and cannot appear in a debugger.

Notice there is no semicolon and no =. A macro is raw text, so this common mistake:

#define MAX_USERS 100;        /* note the semicolon */

int limit = MAX_USERS + 1;    /* expands to: int limit = 100; + 1;  -> error */

produces an error on a line that looks nothing like the definition. The uppercase naming convention for macros exists precisely so that readers know a substitution is happening.

Macros are conventionally written in UPPER_CASE; const variables usually follow it too when they stand in for the same idea.

Enum Constants

The third form gives you a set of named integers:

#include <stdio.h>

enum { MAX_USERS = 100, BUFFER_SIZE = 256 };

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

int main(void) {
    char buffer[BUFFER_SIZE];   /* a genuine compile-time constant */

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

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

Values start at 0 and increase by one unless you assign them, so MON is 0 and FRI is 4. An anonymous enum { ... } is a common idiom for plain integer constants.

Enum constants have a real advantage over both alternatives: they are compile-time integer constants the compiler understands, and they are visible to the debugger. The full story is on enums in C.

Which One to Use

The default should be const. Reach for #define when the value has to exist before compilation, and enum when you need a compile-time integer or a named group.

The one place this really bites is array sizes:

#include <stdio.h>

#define DEFINED_SIZE 5
enum { ENUM_SIZE = 5 };

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

int main(void) {
    const int const_size = 5;
    int local[const_size];    /* C99 variable-length array - works here... */

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

A const int in C is a read-only variable, not a compile-time constant expression. Inside a function C99 accepts int local[const_size] by making it a variable-length array; at file scope, in a struct, or as a case label it is rejected outright. enum and #define work everywhere.

(This is one of the real differences from C++, where const int is a constant expression. Code that moves between the languages trips on it.)

const With Pointers

const and pointers combine in three ways, and the meanings are not interchangeable. Read the declaration outward from the name:

const char *p;          /* p points at chars that must not be modified */
char * const q;         /* q itself cannot be re-pointed; the chars can change */
const char * const r;   /* neither the pointer nor the chars can change */

#include <stdio.h>

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

    const char *p = text;
    /* *p = 'H';  <- error: the data is const through p */
    p = "world";  /* but re-pointing p is fine */
    printf("p now points at: %s\n", p);

    char * const q = text;
    q[0] = 'H';   /* modifying the data through q is fine */
    /* q = "world";  <- error: q itself is const */
    printf("text is now: %s\n", text);
    return 0;
}

The const char * form is the one you will write most, because it is the correct type for a function parameter that reads a string without changing it:

#include <stdio.h>

/* The const promises the caller: this function will not modify your string. */
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("vowels in \"programming\": %zu\n", count_vowels("programming"));
    return 0;
}

Adding const to a read-only parameter costs nothing and documents the contract in a way the compiler enforces. It is worth doing everywhere.

String Literals Are Effectively const

A subtle trap that const exists to catch:

char *s = "hello";   /* legal C, but s points into read-only memory */
s[0] = 'H';          /* undefined behavior - usually a crash */

String literals live in a read-only section of the executable. Writing through that pointer typically segfaults. Declaring the pointer const char *s = "hello"; makes the compiler reject the assignment instead of letting it crash at runtime.

If you need a modifiable string, copy it into an array:

#include <stdio.h>

int main(void) {
    const char *literal = "hello";   /* read-only, cannot be modified */
    char copy[] = "hello";           /* an array: a private, modifiable copy */

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