C Notes

Hub Applications of C Programming Language Features of C Programming Language History of C Programming Language What is C Language?Why Learn C Programming in 2024?First C Program - Hello World in C with Explanation GCC Compiler - Complete Guide to GNU C Compiler Install C Compiler on Linux - GCC Setup Guide for All Distros Install C Compiler on macOS - Xcode Command Line Tools and Homebrew GCC Install C Compiler on Windows - MinGW, MSYS2, and WSL Guide Setup VS Code for C Programming - Complete Configuration Guide C Syntax Rules — Complete Guide Comments in C Programming Constants in C Programming Data Types in C Identifiers in C Programming Keywords in C Programming Structure of a C Program Variables in C Programming Arithmetic Operators in C Programming Assignment Operators in C Programming Bitwise Operators in C Programming Increment and Decrement Operators in C Logical Operators in C Programming Relational Operators in C Programming Ternary Operator in C Programming Break Statement in C Programming Continue Statement in C Programming Do-While Loop in C Programming For Loop in C Programming Goto Statement in C Programming if-else Statement in C Programming if Statement in C Programming Nested if Statements in C Programming Switch Statement in C Programming While Loop in C Programming Function Arguments in C - Pass by Value vs Pass by Reference Function Call in C Programming Function Declaration (Prototype) in C Function Definition in C Programming Introduction to Functions in C Programming Recursion in C Programming Return Statement in C Programming Storage Classes in C Programming Array Operations in C - Searching, Sorting, Insert and Delete Array Programs in C - Reverse, Rotate, Duplicates, Merge Introduction to Arrays in C Programming Multidimensional Arrays in C Programming One Dimensional Arrays in C Programming Passing Arrays to Functions in C Two Dimensional Arrays in C Programming String Comparison in C - strcmp, strncmp, Case-Insensitive String Functions in C - strlen, strcpy, strcat, strcmp C String Handling Library - Complete string.h Reference String Manipulation in C - Reverse, Uppercase, Palindrome String Programs in C - Anagram, Word Count, Vowels, Frequency Strings in C Programming - Complete Introduction Double Pointers in C - Pointer to Pointer Pointer Arithmetic in C Programming Pointer Declaration and Initialization in C Pointer Programs in C - Swap, String Reversal, Dynamic Allocation Pointers and Arrays in C - The Relationship Explained Pointers and Functions in C - Pass by Reference Introduction to Pointers in C Programming Void Pointers in C - Generic Pointers Guide calloc() in C – Contiguous Memory Allocation Dynamic Arrays in C – Runtime-Sized Arrays free() in C – Releasing Dynamic Memory malloc() in C – Dynamic Memory Allocation Memory Management Best Practices in C realloc() in C – Resizing Dynamic Memory Binary Files in C – fread and fwrite File Handling in C – Introduction File Handling Projects in C – Student Records & Phone Book File Modes in C – Complete Guide fopen() and fclose() in C – Opening and Closing Files Reading Files in C – fgetc, fgets, fscanf, fread Writing Files in C – fputc, fputs, fprintf, fwrite Conditional Compilation in C – #ifdef, #ifndef, #if #define Macros in C – Constants and Macro Functions Header Files in C – Creating Custom Headers #include Directive in C – File Inclusion Macro Functions in C – Parameterized Macros C Preprocessor – Overview and Directives Graphs in C – Adjacency Matrix, Adjacency List, BFS, and DFS Hash Tables in C – Implementation, Collision Handling, and Chaining Linked List in C – Singly, Doubly, and Circular with Implementation Queue in C – Linear, Circular, and Priority Queue Implementation Stack in C – Array and Linked List Implementation with Applications Trees in C – Binary Search Tree Implementation with Traversals C Programming Best Practices – Coding Standards, Safety, and Performance Bit Fields in C – Definition, Use Cases, and Protocol Headers C Standard Library Overview – All Headers and Common Functions Command Line Arguments in C – argc and argv Explained Debugging Techniques in C – GDB, Valgrind, and Sanitizers Function Pointers in C – Complete Guide with Examples Memory Layout of a C Program – Text, Data, BSS, Heap, Stack Bank Management System in C – Complete Project with File Storage File Encryption Tool in C – XOR Cipher Implementation Library Management System in C – Complete Project with Source Code Mini Compiler in C – Lexer and Parser for Simple Expressions Snake Game in C – Console-Based Game with Source Code Student Management System in C – Complete Project with Source Code C Programming Cheatsheet – Complete Quick Reference Guide Top 50 C Programming Interview Questions with Answers (2025)Memory Management Interview Questions in C with Answers Output Prediction Questions in C – What Will This Program Print?Pointer Interview Questions in C – Tricky Problems with Answers Common C Programming Errors and Solutions – Debugging Guide Important C Programs – 50+ Frequently Asked Programs with Solutions Quick Revision Notes for C Programming – Complete C in 10 Minutes Recommended C Programming Books – From Beginner to Expert Format Specifiers in C - Complete Reference getchar() and putchar() in C Programming gets() and puts() in C Programming C Input Output Programs and Examples printf() Function in C Programming scanf() Function in C Programming Arrays of Structures in C – Managing Collections Enums in C – Enumerated Data Types Nested Structures in C – Struct Within Struct Pointers to Structures in C – Arrow Operator Structures in C – User-Defined Data Types typedef in C – Creating Type Aliases Unions in C – Shared Memory Data Types

Constants in C Programming

Learn about constants in C programming — const keyword, #define macro, enum constants, and literal constants with practical examples and best practices.

In everyday life, some values never change — the speed of light, the number of days in a week, or the value of pi. In C programming, we often work with values that should remain fixed throughout the program's execution. That's exactly what constants are for.

A constant is a value that, once defined, cannot be altered by the program during execution. Using constants makes your code safer, more readable, and easier to maintain.

Ways to Define Constants in C

C provides several ways to create constants:

Method	Syntax	Scope	Type-checked
`const` keyword	`const int MAX = 100;`	Block/file	Yes
`#define` macro	`#define MAX 100`	File (from point of definition)	No
`enum`	`enum { MAX = 100 };`	Block/file	Yes
Literal constants	`42`, `'A'`, `3.14`	N/A (inline)	Yes

1. The `const` Keyword

The const qualifier tells the compiler that a variable's value must not change after initialization. It's the most modern and type-safe way to define constants.

c example

#include <stdio.h>

int main() {
    const int MAX_SCORE = 100;
    const float PI = 3.14159;
    const char NEWLINE = '\n';

    printf("Maximum score: %d\n", MAX_SCORE);
    printf("Value of PI: %.5f\n", PI);
    printf("Newline character: %c", NEWLINE);

    // MAX_SCORE = 200;  // ERROR: assignment to read-only variable

    return 0;
}

Output

Maximum score: 100
Value of PI: 3.14159
Newline character:

Key Points About `const`

Must be initialized at the time of declaration
The compiler enforces immutability — any modification attempt causes a compile error
Has proper scope (local or global depending on where declared)
Occupies memory like a normal variable
Type-checked by the compiler (catches type mismatch errors)

`const` with Pointers

Using const with pointers can be tricky. There are three variations:

c example

#include <stdio.h>

int main() {
    int x = 10, y = 20;

    // Pointer to constant data — can't modify *p1
    const int *p1 = &x;
    // *p1 = 30;  // ERROR
    p1 = &y;     // OK — pointer itself can change

    // Constant pointer — can't modify p2 itself
    int *const p2 = &x;
    *p2 = 30;    // OK — data can be modified
    // p2 = &y;  // ERROR

    // Constant pointer to constant data — nothing can change
    const int *const p3 = &x;
    // *p3 = 40;  // ERROR
    // p3 = &y;   // ERROR

    printf("x = %d\n", x);
    return 0;
}

Output

x = 30

Declaration	Modify data (*p)	Modify pointer
const int *p	No	Yes
int *const p	Yes	No
const int *const p	No	No

Summary of const with pointers

2. The `#define` Preprocessor Macro

The #define directive creates a symbolic constant that gets replaced by the preprocessor before compilation. It's essentially a text substitution mechanism.

c example

#include <stdio.h>

#define PI 3.14159
#define MAX_SIZE 100
#define GREETING "Hello, World!"

int main() {
    float radius = 5.0;
    float area = PI * radius * radius;

    printf("Area of circle: %.2f\n", area);
    printf("Max array size: %d\n", MAX_SIZE);
    printf("%s\n", GREETING);

    return 0;
}

Output

Area of circle: 78.54
Max array size: 100
Hello, World!

How `#define` Works

When the preprocessor encounters #define PI 3.14159, it replaces every occurrence of PI in the code with 3.14159 before the compiler even sees it. It's pure text replacement.

`#define` vs `const` — Which to Use?

Feature	`#define`	`const`
Type checking	No	Yes
Memory allocation	No (text replacement)	Yes
Debugging	Harder (name not in symbol table)	Easier
Scope	From definition to end of file (or `#undef`)	Block or file scope
Can be used in `switch` cases	Yes	No (in C89)
Can define expressions	Yes	No
Visible in debugger	No	Yes

Macro with Expressions

c example

#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))

Warning: Always wrap macro parameters in parentheses to avoid unexpected operator precedence issues.

3. Enum Constants

Enumerations (enum) create a set of named integer constants. They're especially useful when you have a group of related constants.

c example

#include <stdio.h>

enum Days {
    SUNDAY = 0,
    MONDAY,    // 1
    TUESDAY,   // 2
    WEDNESDAY, // 3
    THURSDAY,  // 4
    FRIDAY,    // 5
    SATURDAY   // 6
};

enum Colors {
    RED = 1,
    GREEN = 2,
    BLUE = 4
};

int main() {
    enum Days today = WEDNESDAY;
    enum Colors favorite = BLUE;

    printf("Wednesday is day number: %d\n", today);
    printf("Blue color code: %d\n", favorite);

    if (today == WEDNESDAY) {
        printf("It's midweek!\n");
    }

    return 0;
}

Output

Wednesday is day number: 3
Blue color code: 4
It's midweek!

Properties of Enum Constants

By default, the first value is 0 and each subsequent value increments by 1
You can assign specific values to any enumerator
Enum constants are of type int
Great for readability — MONDAY is clearer than 1
Type-checked by the compiler

Practical Use of Enums

Example

#include <stdio.h> enum Boolean { FALSE, TRUE }; enum Direction { UP, DOWN, LEFT, RIGHT }; int main() { enum Boolean isReady = TRUE; enum Direction move = LEFT; if (isReady == TRUE) { printf("System is ready\n"); } switch (move) { case UP: printf("Moving up\n"); break; case DOWN: printf("Moving down\n"); break; case LEFT: printf("Moving left\n"); break; case RIGHT: printf("Moving right\n"); break; } return 0; }

Output

System is ready
Moving left

4. Literal Constants

Literal constants are fixed values written directly in the code. They don't have names — they're the raw values themselves.

Integer Literals

c example

int decimal = 42;        // decimal (base 10)
int octal = 052;         // octal (base 8) — prefix 0
int hex = 0x2A;          // hexadecimal (base 16) — prefix 0x
long big = 100000L;      // long integer — suffix L
unsigned int positive = 42U;  // unsigned — suffix U

Floating-Point Literals

c example

float f1 = 3.14f;       // float — suffix f
double d1 = 3.14;       // double (default)
double d2 = 2.5e3;      // scientific notation: 2500.0
long double ld = 3.14L; // long double — suffix L

Character Literals

c example

char ch = 'A';           // single character
char newline = '\n';     // escape sequence
char tab = '\t';         // tab character
char null_char = '\0';   // null character

String Literals

c example

char *msg = "Hello, C!";          // string literal
char *path = "C:\\Users\\file";   // escaped backslash
char *multiline = "Line one "
                  "Line two";     // concatenated strings

Common Escape Sequences

Escape Sequence	Meaning
`\n`	Newline
`\t`	Tab
`\\`	Backslash
`\'`	Single quote
`\"`	Double quote
`\0`	Null character
`\a`	Alert (beep)
`\r`	Carriage return

Complete Example: Using All Types of Constants

c example

#include <stdio.h>

#define COMPANY "TechCorp"
#define TAX_RATE 0.18

enum Department { HR, ENGINEERING, MARKETING, FINANCE };

int main() {
    const int BASE_SALARY = 50000;
    const int BONUS = 5000;
    enum Department dept = ENGINEERING;

    int total = BASE_SALARY + BONUS;
    float tax = total * TAX_RATE;
    float net = total - tax;

    printf("Company: %s\n", COMPANY);
    printf("Department: %d\n", dept);
    printf("Base Salary: %d\n", BASE_SALARY);
    printf("Bonus: %d\n", BONUS);
    printf("Tax (%.0f%%): %.2f\n", TAX_RATE * 100, tax);
    printf("Net Salary: %.2f\n", net);

    return 0;
}

Output

Company: TechCorp
Department: 1
Base Salary: 50000
Bonus: 5000
Tax (18%): 9900.00
Net Salary: 45100.00

Best Practices for Using Constants

Use UPPERCASE names for constants (MAX_SIZE, PI, BUFFER_LENGTH)
Prefer const over #define for type safety and debuggability
Use enums for related groups of integer constants
Never use magic numbers — define named constants for all literal values
Document the purpose of constants with comments when the name isn't self-explanatory

Interview Questions on Constants in C

Q1: What is the difference between const and #define in C?

const creates a typed, scoped variable that the compiler can type-check and that appears in the debugger. #define is a preprocessor text substitution — it has no type, no scope, and doesn't allocate memory. Modern C prefers const for most use cases.

Q2: Can you modify a const variable using a pointer?

Technically, you can bypass const using pointer casting (*(int*)&constVar = newValue;), but this leads to undefined behavior. The compiler may have optimized code assuming the value never changes.

Q3: Where are constants stored in memory?

const global variables are typically stored in the read-only data segment (.rodata). #define constants don't occupy separate memory — they're substituted inline. Enum constants are compile-time values.

Q4: Can #define have a semicolon at the end?

No, you should not put a semicolon after #define values. Since it's text substitution, the semicolon would be pasted everywhere the macro is used, potentially causing errors.

Q5: What are the advantages of using enum over #define for related constants?

Enums provide: (1) automatic sequential numbering, (2) type checking, (3) better debugging (values appear by name), (4) logical grouping of related values, and (5) scope management.

Summary

Constants are values that cannot be changed during program execution.
C provides four ways to define constants: const, #define, enum, and literal constants.
const is type-safe and scoped — preferred in modern C code.
#define performs text substitution before compilation — no type checking.
enum is ideal for groups of related integer constants.
Literal constants are unnamed fixed values used directly in code.
Following naming conventions (UPPERCASE) makes constants easily identifiable.
Using constants improves code readability, maintainability, and prevents accidental modifications.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Constants in C Programming.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this C Programming topic.

Search Terms

c-programming, c programming, programming, basics, constants, constants in c programming

Continue learning this concept

BasicsC Syntax Rules — Complete GuideLearn the fundamental syntax rules of C programming — statements, expressions, semicolons, code blocks, whitespace handling, and common syntax errors explained with examples.BasicsComments in C ProgrammingLearn about comments in C — single-line comments, multi-line comments, best practices, nested comments, and when to use comments effectively in your code.BasicsData Types in CComplete guide to C data types — primary types (int, char, float, double), derived types (arrays, pointers, structures), type modifiers (short, long, signed, unsigned), sizeof operator, type conversion, and memory representation with examples.BasicsIdentifiers in C ProgrammingComplete guide to identifiers in C — naming rules, conventions, valid and invalid examples, and the difference between identifiers and keywords.BasicsKeywords in C ProgrammingComplete guide to all 32 keywords in C programming — categorized by purpose with explanations, usage examples, and comparison tables.BasicsStructure of a C ProgramComplete explanation of C program structure — documentation section, preprocessor directives, global declarations, main function, user-defined functions, and how each section works together with practical examples.

PreviousComments in C Programming NextData Types in C

C Notes

Constants in C Programming

Learn about constants in C programming — const keyword, #define macro, enum constants, and literal constants with practical examples and best practices.

A constant is a value that, once defined, cannot be altered by the program during execution. Using constants makes your code safer, more readable, and easier to maintain.

Ways to Define Constants in C

C provides several ways to create constants:

Method	Syntax	Scope	Type-checked
`const` keyword	`const int MAX = 100;`	Block/file	Yes
`#define` macro	`#define MAX 100`	File (from point of definition)	No
`enum`	`enum { MAX = 100 };`	Block/file	Yes
Literal constants	`42`, `'A'`, `3.14`	N/A (inline)	Yes

1. The `const` Keyword

The const qualifier tells the compiler that a variable's value must not change after initialization. It's the most modern and type-safe way to define constants.

c example

#include <stdio.h>

int main() {
    const int MAX_SCORE = 100;
    const float PI = 3.14159;
    const char NEWLINE = '\n';

    printf("Maximum score: %d\n", MAX_SCORE);
    printf("Value of PI: %.5f\n", PI);
    printf("Newline character: %c", NEWLINE);

    // MAX_SCORE = 200;  // ERROR: assignment to read-only variable

    return 0;
}

Output

Maximum score: 100
Value of PI: 3.14159
Newline character:

Key Points About `const`

Must be initialized at the time of declaration
The compiler enforces immutability — any modification attempt causes a compile error
Has proper scope (local or global depending on where declared)
Occupies memory like a normal variable
Type-checked by the compiler (catches type mismatch errors)

`const` with Pointers

Using const with pointers can be tricky. There are three variations:

c example

#include <stdio.h>

int main() {
    int x = 10, y = 20;

    // Pointer to constant data — can't modify *p1
    const int *p1 = &x;
    // *p1 = 30;  // ERROR
    p1 = &y;     // OK — pointer itself can change

    // Constant pointer — can't modify p2 itself
    int *const p2 = &x;
    *p2 = 30;    // OK — data can be modified
    // p2 = &y;  // ERROR

    // Constant pointer to constant data — nothing can change
    const int *const p3 = &x;
    // *p3 = 40;  // ERROR
    // p3 = &y;   // ERROR

    printf("x = %d\n", x);
    return 0;
}

Output

x = 30

Declaration	Modify data (*p)	Modify pointer
const int *p	No	Yes
int *const p	Yes	No
const int *const p	No	No

Summary of const with pointers

2. The `#define` Preprocessor Macro

The #define directive creates a symbolic constant that gets replaced by the preprocessor before compilation. It's essentially a text substitution mechanism.

c example

#include <stdio.h>

#define PI 3.14159
#define MAX_SIZE 100
#define GREETING "Hello, World!"

int main() {
    float radius = 5.0;
    float area = PI * radius * radius;

    printf("Area of circle: %.2f\n", area);
    printf("Max array size: %d\n", MAX_SIZE);
    printf("%s\n", GREETING);

    return 0;
}

Output

Area of circle: 78.54
Max array size: 100
Hello, World!

How `#define` Works

When the preprocessor encounters #define PI 3.14159, it replaces every occurrence of PI in the code with 3.14159 before the compiler even sees it. It's pure text replacement.

`#define` vs `const` — Which to Use?

Feature	`#define`	`const`
Type checking	No	Yes
Memory allocation	No (text replacement)	Yes
Debugging	Harder (name not in symbol table)	Easier
Scope	From definition to end of file (or `#undef`)	Block or file scope
Can be used in `switch` cases	Yes	No (in C89)
Can define expressions	Yes	No
Visible in debugger	No	Yes

Macro with Expressions

c example

#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))

Warning: Always wrap macro parameters in parentheses to avoid unexpected operator precedence issues.

3. Enum Constants

Enumerations (enum) create a set of named integer constants. They're especially useful when you have a group of related constants.

c example

#include <stdio.h>

enum Days {
    SUNDAY = 0,
    MONDAY,    // 1
    TUESDAY,   // 2
    WEDNESDAY, // 3
    THURSDAY,  // 4
    FRIDAY,    // 5
    SATURDAY   // 6
};

enum Colors {
    RED = 1,
    GREEN = 2,
    BLUE = 4
};

int main() {
    enum Days today = WEDNESDAY;
    enum Colors favorite = BLUE;

    printf("Wednesday is day number: %d\n", today);
    printf("Blue color code: %d\n", favorite);

    if (today == WEDNESDAY) {
        printf("It's midweek!\n");
    }

    return 0;
}

Output

Wednesday is day number: 3
Blue color code: 4
It's midweek!

Properties of Enum Constants

By default, the first value is 0 and each subsequent value increments by 1
You can assign specific values to any enumerator
Enum constants are of type int
Great for readability — MONDAY is clearer than 1
Type-checked by the compiler

Practical Use of Enums

Example

Output

System is ready
Moving left

4. Literal Constants

Literal constants are fixed values written directly in the code. They don't have names — they're the raw values themselves.

Integer Literals

c example

int decimal = 42;        // decimal (base 10)
int octal = 052;         // octal (base 8) — prefix 0
int hex = 0x2A;          // hexadecimal (base 16) — prefix 0x
long big = 100000L;      // long integer — suffix L
unsigned int positive = 42U;  // unsigned — suffix U

Floating-Point Literals

c example

float f1 = 3.14f;       // float — suffix f
double d1 = 3.14;       // double (default)
double d2 = 2.5e3;      // scientific notation: 2500.0
long double ld = 3.14L; // long double — suffix L

Character Literals

c example

char ch = 'A';           // single character
char newline = '\n';     // escape sequence
char tab = '\t';         // tab character
char null_char = '\0';   // null character

String Literals

c example

char *msg = "Hello, C!";          // string literal
char *path = "C:\\Users\\file";   // escaped backslash
char *multiline = "Line one "
                  "Line two";     // concatenated strings

Common Escape Sequences

Escape Sequence	Meaning
`\n`	Newline
`\t`	Tab
`\\`	Backslash
`\'`	Single quote
`\"`	Double quote
`\0`	Null character
`\a`	Alert (beep)
`\r`	Carriage return

Complete Example: Using All Types of Constants

c example

#include <stdio.h>

#define COMPANY "TechCorp"
#define TAX_RATE 0.18

enum Department { HR, ENGINEERING, MARKETING, FINANCE };

int main() {
    const int BASE_SALARY = 50000;
    const int BONUS = 5000;
    enum Department dept = ENGINEERING;

    int total = BASE_SALARY + BONUS;
    float tax = total * TAX_RATE;
    float net = total - tax;

    printf("Company: %s\n", COMPANY);
    printf("Department: %d\n", dept);
    printf("Base Salary: %d\n", BASE_SALARY);
    printf("Bonus: %d\n", BONUS);
    printf("Tax (%.0f%%): %.2f\n", TAX_RATE * 100, tax);
    printf("Net Salary: %.2f\n", net);

    return 0;
}

Output

Company: TechCorp
Department: 1
Base Salary: 50000
Bonus: 5000
Tax (18%): 9900.00
Net Salary: 45100.00

Best Practices for Using Constants

Use UPPERCASE names for constants (MAX_SIZE, PI, BUFFER_LENGTH)
Prefer const over #define for type safety and debuggability
Use enums for related groups of integer constants
Never use magic numbers — define named constants for all literal values
Document the purpose of constants with comments when the name isn't self-explanatory

Interview Questions on Constants in C

Q1: What is the difference between const and #define in C?

Q2: Can you modify a const variable using a pointer?

Q3: Where are constants stored in memory?

Q4: Can #define have a semicolon at the end?

No, you should not put a semicolon after #define values. Since it's text substitution, the semicolon would be pasted everywhere the macro is used, potentially causing errors.

Q5: What are the advantages of using enum over #define for related constants?

Enums provide: (1) automatic sequential numbering, (2) type checking, (3) better debugging (values appear by name), (4) logical grouping of related values, and (5) scope management.

Summary

Constants are values that cannot be changed during program execution.
C provides four ways to define constants: const, #define, enum, and literal constants.
const is type-safe and scoped — preferred in modern C code.
#define performs text substitution before compilation — no type checking.
enum is ideal for groups of related integer constants.
Literal constants are unnamed fixed values used directly in code.
Following naming conventions (UPPERCASE) makes constants easily identifiable.
Using constants improves code readability, maintainability, and prevents accidental modifications.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Constants in C Programming.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this C Programming topic.

Search Terms

c-programming, c programming, programming, basics, constants, constants in c programming

Continue learning this concept

PreviousComments in C Programming NextData Types in C

Ways to Define Constants in C

1. The const Keyword

Key Points About const

const with Pointers

2. The #define Preprocessor Macro

How #define Works

#define vs const — Which to Use?

Macro with Expressions

3. Enum Constants

Properties of Enum Constants

Practical Use of Enums

4. Literal Constants

Integer Literals

Floating-Point Literals

Character Literals

String Literals

Common Escape Sequences

Complete Example: Using All Types of Constants

Best Practices for Using Constants

Interview Questions on Constants in C

Summary

Continue learning this concept

Ways to Define Constants in C

1. The const Keyword

Key Points About const

const with Pointers

2. The #define Preprocessor Macro

How #define Works

#define vs const — Which to Use?

Macro with Expressions

3. Enum Constants

Properties of Enum Constants

Practical Use of Enums

4. Literal Constants

Integer Literals

Floating-Point Literals

Character Literals

String Literals

Common Escape Sequences

Complete Example: Using All Types of Constants

Best Practices for Using Constants

Interview Questions on Constants in C

Summary

Continue learning this concept

1. The `const` Keyword

Key Points About `const`

`const` with Pointers

2. The `#define` Preprocessor Macro

How `#define` Works

`#define` vs `const` — Which to Use?

1. The `const` Keyword

Key Points About `const`

`const` with Pointers

2. The `#define` Preprocessor Macro

How `#define` Works

`#define` vs `const` — Which to Use?