Constants in C

Some values in a program should never change: the number of days in a week, a sales tax rate, the seats on a plane. Constants in C let you give these values a name and lock them so they can't be changed by accident. In this lesson, you'll learn the three kinds of constants: literals, const variables and #define names.

What is a constant in C?

A constant is a value that stays the same for the whole run of the program. If code tries to change a const value, the compiler refuses to build the program. That protection is the whole point: constants turn "please don't change this" into a rule the compiler checks for you.

Literals: values written directly in code

The simplest constants are literals, the raw values you type straight into your code:

#include <stdio.h>

int main(void) {
    printf("%d\n", 250);       /* integer literal */
    printf("%.2f\n", 19.99);   /* floating-point literal */
    printf("%c\n", 'Z');       /* character literal */
    printf("%s\n", "Hello");   /* string literal */
    printf("%d\n", 0x1F);      /* hexadecimal integer literal */
    return 0;
}

250
19.99
Z
Hello
31

The 0x prefix means the number is written in hexadecimal (base 16), and 1F in hex is 31. The %s placeholder prints text; you'll see it again in format specifiers.

The const keyword

Putting const in front of a declaration makes a read-only variable. You must give it a value when you declare it, because you won't be allowed to assign one later.

#include <stdio.h>

int main(void) {
    const double TAX_RATE = 0.08;
    double price = 50.00;
    double tax = price * TAX_RATE;

    printf("Price: %.2f\n", price);
    printf("Tax: %.2f\n", tax);
    printf("Total: %.2f\n", price + tax);
    return 0;
}

Price: 50.00
Tax: 4.00
Total: 54.00

If the tax rate changes next year, you update one line and every calculation follows. Compare that with typing 0.08 in ten different places and hoping you find them all.

Constants also make calculations read like plain English:

#include <stdio.h>

int main(void) {
    const int SECONDS_PER_MINUTE = 60;
    const int MINUTES_PER_HOUR = 60;
    const int HOURS_PER_DAY = 24;

    int seconds_per_day = SECONDS_PER_MINUTE * MINUTES_PER_HOUR * HOURS_PER_DAY;
    printf("A day has %d seconds\n", seconds_per_day);
    return 0;
}

A day has 86400 seconds

#define: named constants from the preprocessor

The other common way to name a constant is #define. It's handled by the preprocessor, the step that runs before the real compiler (you saw it in how C compiles). It works like find-and-replace: every time the name appears, it's swapped for the value.

#include <stdio.h>

#define MAX_SEATS 150

int main(void) {
    int booked = 138;
    int available = MAX_SEATS - booked;

    printf("Seats on this flight: %d\n", MAX_SEATS);
    printf("Booked: %d\n", booked);
    printf("Still available: %d\n", available);
    return 0;
}

Seats on this flight: 150
Booked: 138
Still available: 12

Notice the syntax: #define NAME value with no equals sign and no semicolon. It's a preprocessor instruction, not a C statement. You'll explore #define in depth in C preprocessor macros.

Why are constants written in UPPER_CASE?

C doesn't require it, but almost every C programmer writes constant names in UPPER_CASE with underscores: MAX_SEATS, TAX_RATE, HOURS_PER_DAY. When you see a capitalized name, you instantly know it's fixed. Ordinary variables stay in lowercase, like booked.

const vs #define: what's the difference?

Real-world example: a parking lot

A parking garage has a fixed number of spots and a fixed hourly rate. Those are constants. The number of cars and the time parked change all day, so those are variables:

#include <stdio.h>

#define TOTAL_SPOTS 200

int main(void) {
    const double HOURLY_RATE = 2.75;
    int spots_taken = 163;
    int hours_parked = 4;

    printf("Free spots: %d of %d\n", TOTAL_SPOTS - spots_taken, TOTAL_SPOTS);
    printf("Fee for %d hours: $%.2f\n", hours_parked, hours_parked * HOURLY_RATE);
    return 0;
}

Free spots: 37 of 200
Fee for 4 hours: $11.00

Common mistakes with constants

1. Trying to change a const

const double TAX_RATE = 0.08;
TAX_RATE = 0.10;

error: assignment of read-only variable 'TAX_RATE'

That error is the compiler doing its job. If a value really needs to change, it shouldn't be a constant.

2. Declaring a const without a value

const int LIMIT; followed by LIMIT = 10; fails for the same reason: you can't assign to a const after declaring it. Always write const int LIMIT = 10; in one go.

3. Adding = or ; to a #define

#define MAX_SEATS = 150   /* wrong: no = */
#define MAX_SEATS 150;    /* wrong: no ; */

Because #define pastes text exactly, the = or ; gets pasted too. MAX_SEATS - booked would become = 150 - booked (a syntax error) or 150; - booked (which ends the statement early and throws the subtraction away). Write just #define MAX_SEATS 150.

4. Using "magic numbers"

Code like total = price * 1.08; works, but nobody knows what 1.08 means. Give it a name, such as const double TAX_MULTIPLIER = 1.08;, and your code explains itself.

Practice exercise

#include <stdio.h>

#define CLASS_SIZE 25

int main(void) {
    const double PRICE_PER_PERSON = 12.50;
    int signed_up = 18;

    printf("Free places: %d\n", CLASS_SIZE - signed_up);
    printf("Money collected: $%.2f\n", signed_up * PRICE_PER_PERSON);
    return 0;
}

Free places: 7
Money collected: $225.00

What's next?

You've been printing values with %d, %.2f and %c. Next, learn every placeholder and how to line up columns neatly in C printf() and format specifiers.