C Basics

C Functions

C Structures

C Standard Libraries

C Advanced

C File Handling

C Errors

C Best Practices

C Constants

❮ Previous Next ❯

C Constants: Unchangeable Values

In C programming, a constant is a value or variable that cannot be changed once it has been defined. While regular variables can have their data updated and modified throughout the lifecycle of a program, constants remain strictly read-only.

Using constants is a crucial best practice in software development. They prevent accidental modifications of critical values (like PI = 3.14159 or MAX_USERS = 100), making your code more secure, readable, and easier to maintain.

There are two primary ways to define constants in C:

  1. Using the const keyword.
  2. Using the #define preprocessor directive.

1. Using the const Keyword

The modern and generally preferred way to create a constant in C is by using the const keyword. When you declare a variable with const, you are instructing the compiler to treat it as a read-only variable.

Syntax

const type variableName = value;

Important Rule: Initialization is Mandatory

When you declare a const variable, you must assign it a value at the exact time of declaration. If you try to declare it first and assign a value later, the compiler will throw an error.

The const Keyword Example

#include <stdio.h>


int main() {
  const int BIRTH_YEAR = 1995; // Read-only variable
  const float PI = 3.14159;


  // BIRTH_YEAR = 2000; // ERROR: assignment of read-only variable 'BIRTH_YEAR'


  printf("Birth Year: %d\n", BIRTH_YEAR);
  printf("Value of PI: %f\n", PI);


  return 0;
}

Pro Tip: By convention, constant variable names are often written in UPPERCASE letters. This visually separates them from standard variables in your code, though it is not technically required by the C compiler.

2. Using the #define Preprocessor Directive

Before the const keyword was fully standardized in older C versions, the #define directive was the standard way to create constants. It is still widely used today, especially in legacy code and embedded systems.

The #define directive doesn't create a variable in memory. Instead, it acts as a "find and replace" tool for the preprocessor before the code is even compiled.

Syntax

#define CONSTANT_NAME value

Notice that there is no equals sign (=) and no semicolon (;) at the end of a #define statement!

The #define Directive Example

#include <stdio.h>


// Defining constants using the preprocessor
#define MAX_SPEED 120
#define GREETING "Welcome to IntricateDevo!"


int main() {
  printf("The speed limit is %d km/h.\n", MAX_SPEED);
  printf("%s\n", GREETING);


  return 0;
}

3. const vs #define: Which Should You Use?

While both methods achieve a similar goal, understanding their differences is essential for writing professional-grade C code.

Feature const Keyword #define Directive
Type Checking Yes. The compiler knows its data type (int, float, etc.), offering better type safety. No. It's a simple text substitution. The compiler doesn't know its type.
Scope Block-scoped. Follows normal variable scoping rules (local vs global). Global scope. Once defined, it's available everywhere below it in the file.
Memory Consumes memory like a standard variable. Doesn't consume memory directly; the value is injected directly into the execution code.
Debugging Easy to debug because it has a memory address and identifier. Harder to debug as the identifier is stripped out before compilation.

Best Practice: Modern C developers generally prefer the const keyword due to strict type checking and predictable scoping, which minimizes bugs in large applications.

4. Types of Constant Literals

Beyond declared variables, C supports various types of literal constants that you use in your everyday code.

A. Integer Constants

Integer constants are whole numbers. They can be decimal (base 10), octal (base 8), or hexadecimal (base 16).

B. Floating-Point Constants

Constants that contain a decimal point or an exponential part.

C. Character Constants

A single character enclosed in single quotes.

D. String Constants

A sequence of characters enclosed in double quotes.

E. Escape Sequence Constants

Some character constants cannot be typed directly (like a new line or a tab). In C, these are represented using an "escape sequence" starting with a backslash \.

5. Frequently Asked Questions (FAQ)

Q: Can I change a constant using pointers?
A: While technically possible by casting away the const qualifier, it leads to undefined behavior. It is highly dangerous and should never be done in production code.

Q: Where should I put my #define statements?
A: They are typically placed at the very top of your C file, immediately after your #include statements, so they are easily accessible and visible globally.

Q: Are string literals considered constants?
A: Yes, in C, string literals like "Hello" are stored in read-only memory. Attempting to modify them directly can cause a segmentation fault in modern operating systems.

Exercise

?

Which of the following is the correct syntax for defining a constant using the preprocessor directive?

❮ Previous Next ❯