Understanding Constants in C

When you're writing C programs, you'll often have values that shouldn't change while the program runs. Think of things like pi (3.14159...), the maximum size of an array, or a tax rate. These are constants—fixed values that stay the same from start to finish.

C gives you a couple different ways to define constants, and each has its place. Let me walk you through both.

Using the const Keyword

The most straightforward approach is declaring a variable with the const keyword. This tells the compiler "hey, this value is set in stone—don't let anything modify it."

Here's what that looks like:

const float pi = 3.14;
const int max_attempts = 5;

Once you've declared these, trying to change them later in your code will throw a compiler error. That's actually a good thing—it catches mistakes before they become bugs.

The syntax is simple: put const before the data type, give it a name, and assign the value right there. You have to assign it immediately because, well, you won't get another chance.

Symbolic Constants with #define

The other option is using #define, which works a bit differently. Instead of creating a variable, you're essentially telling the preprocessor to do a find-and-replace before your code even compiles.

#define PI 3.14
#define MAX_SIZE 100

Notice there's no equals sign and no semicolon. That trips people up at first.

What happens here is the preprocessor scans through your code before compilation and swaps out every instance of PI with 3.14. By the time the compiler sees your code, it's as if you typed 3.14 everywhere yourself.

You'll often see these written in all caps. That's just a convention—it helps other programmers (and future you) recognize that something is a constant at a glance.

Here's a slightly odd but useful example:

#define print printf

Now you can write print("Hello") instead of printf("Hello"). The preprocessor just substitutes one for the other. I wouldn't necessarily recommend this particular usage, but it shows how flexible #define can be.

Which Should You Use?

Both approaches work, but const variables are generally preferred in modern C code. They're type-safe (the compiler knows pi is a float), and they play nicer with debugging tools since they're actual variables with names.

#define still has its uses, especially for conditional compilation and macros, but for simple constants, const is usually the cleaner choice.

Quick Recap

Constants prevent accidental changes to values that should stay fixed. You can create them with const (which makes a read-only variable) or #define (which does text substitution before compilation). Either way, they make your code safer and more readable—anyone looking at your program knows immediately that MAX_USERS isn't going to change halfway through.

That's really all there is to it. Constants are a small concept, but using them well is one of those habits that separates clean code from messy code.