In C programming, a constant is a value that cannot be changed by the program during its

execution. Once a constant is defined and initialized, its value remains the same throughout the
entire lifetime of the program. Constants are used to represent fixed values like mathematical
constants (e.g., pi), physical constants, or fixed configuration values.
C provides several ways to define constants:
1. Using the const Keyword:
●​ The const keyword is a type qualifier that can be applied to a variable declaration. When a
variable is declared with const, the compiler prevents any subsequent modification of its
value.
const int MAX_VALUE = 100;​
const float PI = 3.14159;​
const char MESSAGE[] = "Hello";​

●​ Characteristics:
○​ const variables are still technically variables, but the compiler enforces their
immutability.
○​ They follow the scope rules of regular variables (local or global).
○​ It's a good practice to initialize const variables at the time of declaration. While you
can declare a const variable without immediate initialization, you won't be able to
assign a value to it later.
2. Using #define Preprocessor Directive (Symbolic Constants or Macros):
●​ The #define preprocessor directive is used to create symbolic constants (often called
macros). The preprocessor replaces all occurrences of the defined name with the
specified value before the actual compilation begins.
#define GRAVITY 9.8​
#define BUFFER_SIZE 512​
#define GREETING "Welcome"​

●​ Characteristics:
○​ #define creates a textual substitution. The preprocessor simply replaces the macro
name with its value throughout the code.
○​ Macros do not have a specific data type associated with them (the type is
determined by the context where they are used).
○​ Macros have global scope within the file where they are defined (from the point of
definition onwards).
○​ They are often written in uppercase by convention to distinguish them from regular
variables.
○​ #define can also be used to create simple function-like macros, but this can
sometimes lead to unexpected behavior due to the textual substitution nature.
3. Enumerations (enum):
●​ Enumerations provide a way to create a set of named integer constants. They are useful
for representing a set of related values.
enum Days {​
SUNDAY,​
MONDAY,​
TUESDAY,​
WEDNESDAY,​
THURSDAY,​
 FRIDAY,​
SATURDAY​
};​
​
enum Status {​
OK = 200,​
ERROR = 404,​
PENDING​
};​

●​ Characteristics:
○​ By default, the enumerators are assigned integer values starting from 0 (SUNDAY =
0, MONDAY = 1, etc.).
○​ You can explicitly assign values to the enumerators, and subsequent uninitialized
enumerators will automatically increment from the last assigned value (as seen in
the Status example).
○​ Enumerations improve code readability by using meaningful names instead of raw
integer values.
○​ Variables of an enumeration type can only be assigned one of the defined
enumerator values.
Types of Constants in C:
C supports various types of constants, just like it supports different data types:
●​ Integer Constants: Whole numbers (e.g., 10, -5, 0). They can be decimal, octal (prefixed
with 0, e.g., 012), or hexadecimal (prefixed with 0x or 0X, e.g., 0xFF). They can also have
suffixes to indicate their type (e.g., 10L for long, 15U for unsigned).
●​ Floating-Point Constants: Numbers with a decimal point (e.g., 3.14, -2.5, 0.0). They can
also be expressed in exponential notation (e.g., 1.2e-3). By default, they are of type
double. You can use suffixes f or F for float (e.g., 3.14f) and l or L for long double (e.g.,
2.71828L).
●​ Character Constants: Single characters enclosed in single quotes (e.g., 'a', '5', ' '). They
represent the ASCII value of the character. Escape sequences (preceded by a backslash
\) are used for special characters (e.g., '\n' for newline, '\t' for tab, '\\' for backslash, '\'' for
single quote).
●​ String Literals: Sequences of characters enclosed in double quotes (e.g., "Hello, world!",
"This is a string"). String literals are stored as arrays of characters terminated by a null
character (\0).
Why Use Constants?
●​ Readability: Using meaningful names for constants (e.g., MAX_SIZE instead of 100)
makes the code easier to understand.
●​ Maintainability: If a fixed value needs to be changed, you only need to modify the
constant's definition in one place, rather than searching and replacing all occurrences in
the code. This reduces the risk of errors.
●​ Preventing Accidental Modification: The compiler enforces the immutability of const
variables, preventing accidental changes that could lead to bugs.
●​ Safety: Using constants can make the code safer by ensuring that certain values remain
fixed as intended.
Choosing Between const and #define:
●​ const:
 ○​ Provides type checking by the compiler.
○​ Follows scope rules, which can be beneficial for local constants.
○​ Is generally preferred for defining named constants that have a specific data type.
○​ Easier for debuggers to handle (can see the value and type of const variables).
●​ #define:
○​ Performs simple textual substitution by the preprocessor.
○​ Does not have type checking.
○​ Has global scope within the file (from the point of definition).
○​ Can be useful for simple constants and macro definitions.
○​ Might not be as visible to debuggers (the preprocessor has already done the
substitution).
In modern C programming, const is generally preferred over #define for defining named
constants due to its type safety and better integration with the language's scope rules and
debugging tools. #define is still commonly used for simple macros and conditional compilation.
Enumerations are specifically useful for representing sets of related integer constants.