C Notes
HubApplications of C Programming LanguageFeatures of C Programming LanguageHistory of C Programming LanguageWhat is C Language?Why Learn C Programming in 2024?First C Program - Hello World in C with ExplanationGCC Compiler - Complete Guide to GNU C CompilerInstall C Compiler on Linux - GCC Setup Guide for All DistrosInstall C Compiler on macOS - Xcode Command Line Tools and Homebrew GCCInstall C Compiler on Windows - MinGW, MSYS2, and WSL GuideSetup VS Code for C Programming - Complete Configuration GuideC Syntax Rules — Complete GuideComments in C ProgrammingConstants in C ProgrammingData Types in CIdentifiers in C ProgrammingKeywords in C ProgrammingStructure of a C ProgramVariables in C ProgrammingArithmetic Operators in C ProgrammingAssignment Operators in C ProgrammingBitwise Operators in C ProgrammingIncrement and Decrement Operators in CLogical Operators in C ProgrammingRelational Operators in C ProgrammingTernary Operator in C ProgrammingBreak Statement in C ProgrammingContinue Statement in C ProgrammingDo-While Loop in C ProgrammingFor Loop in C ProgrammingGoto Statement in C Programmingif-else Statement in C Programmingif Statement in C ProgrammingNested if Statements in C ProgrammingSwitch Statement in C ProgrammingWhile Loop in C ProgrammingFunction Arguments in C - Pass by Value vs Pass by ReferenceFunction Call in C ProgrammingFunction Declaration (Prototype) in CFunction Definition in C ProgrammingIntroduction to Functions in C ProgrammingRecursion in C ProgrammingReturn Statement in C ProgrammingStorage Classes in C ProgrammingArray Operations in C - Searching, Sorting, Insert and DeleteArray Programs in C - Reverse, Rotate, Duplicates, MergeIntroduction to Arrays in C ProgrammingMultidimensional Arrays in C ProgrammingOne Dimensional Arrays in C ProgrammingPassing Arrays to Functions in CTwo Dimensional Arrays in C ProgrammingString Comparison in C - strcmp, strncmp, Case-InsensitiveString Functions in C - strlen, strcpy, strcat, strcmpC String Handling Library - Complete string.h ReferenceString Manipulation in C - Reverse, Uppercase, PalindromeString Programs in C - Anagram, Word Count, Vowels, FrequencyStrings in C Programming - Complete IntroductionDouble Pointers in C - Pointer to PointerPointer Arithmetic in C ProgrammingPointer Declaration and Initialization in CPointer Programs in C - Swap, String Reversal, Dynamic AllocationPointers and Arrays in C - The Relationship ExplainedPointers and Functions in C - Pass by ReferenceIntroduction to Pointers in C ProgrammingVoid Pointers in C - Generic Pointers Guidecalloc() in C – Contiguous Memory AllocationDynamic Arrays in C – Runtime-Sized Arraysfree() in C – Releasing Dynamic Memorymalloc() in C – Dynamic Memory AllocationMemory Management Best Practices in Crealloc() in C – Resizing Dynamic MemoryBinary Files in C – fread and fwriteFile Handling in C – IntroductionFile Handling Projects in C – Student Records & Phone BookFile Modes in C – Complete Guidefopen() and fclose() in C – Opening and Closing FilesReading Files in C – fgetc, fgets, fscanf, freadWriting Files in C – fputc, fputs, fprintf, fwriteConditional Compilation in C – #ifdef, #ifndef, #if#define Macros in C – Constants and Macro FunctionsHeader Files in C – Creating Custom Headers#include Directive in C – File InclusionMacro Functions in C – Parameterized MacrosC Preprocessor – Overview and DirectivesGraphs in C – Adjacency Matrix, Adjacency List, BFS, and DFSHash Tables in C – Implementation, Collision Handling, and ChainingLinked List in C – Singly, Doubly, and Circular with ImplementationQueue in C – Linear, Circular, and Priority Queue ImplementationStack in C – Array and Linked List Implementation with ApplicationsTrees in C – Binary Search Tree Implementation with TraversalsC Programming Best Practices – Coding Standards, Safety, and PerformanceBit Fields in C – Definition, Use Cases, and Protocol HeadersC Standard Library Overview – All Headers and Common FunctionsCommand Line Arguments in C – argc and argv ExplainedDebugging Techniques in C – GDB, Valgrind, and SanitizersFunction Pointers in C – Complete Guide with ExamplesMemory Layout of a C Program – Text, Data, BSS, Heap, StackBank Management System in C – Complete Project with File StorageFile Encryption Tool in C – XOR Cipher ImplementationLibrary Management System in C – Complete Project with Source CodeMini Compiler in C – Lexer and Parser for Simple ExpressionsSnake Game in C – Console-Based Game with Source CodeStudent Management System in C – Complete Project with Source CodeC Programming Cheatsheet – Complete Quick Reference GuideTop 50 C Programming Interview Questions with Answers (2025)Memory Management Interview Questions in C with AnswersOutput Prediction Questions in C – What Will This Program Print?Pointer Interview Questions in C – Tricky Problems with AnswersCommon C Programming Errors and Solutions – Debugging GuideImportant C Programs – 50+ Frequently Asked Programs with SolutionsQuick Revision Notes for C Programming – Complete C in 10 MinutesRecommended C Programming Books – From Beginner to ExpertFormat Specifiers in C - Complete Referencegetchar() and putchar() in C Programminggets() and puts() in C ProgrammingC Input Output Programs and Examplesprintf() Function in C Programmingscanf() Function in C ProgrammingArrays of Structures in C – Managing CollectionsEnums in C – Enumerated Data TypesNested Structures in C – Struct Within StructPointers to Structures in C – Arrow OperatorStructures in C – User-Defined Data Typestypedef in C – Creating Type AliasesUnions in C – Shared Memory Data Types
Complete guide to enums in C programming — definition, syntax, automatic and custom values, enum vs #define, use in switch statements, bit flags, practical examples with output.
When your code has a fixed set of named options — days of the week, colors, states, error codes — using raw integers like 0, 1, 2 makes your code unreadable. Enums (enumerated types) let you define meaningful names for these integer constants, making your code self-documenting.
What is an Enum?
An enum is a user-defined type that consists of a set of named integer constants:
c example
enum Day {
SUNDAY, // 0
MONDAY, // 1
TUESDAY, // 2
WEDNESDAY, // 3
THURSDAY, // 4
FRIDAY, // 5
SATURDAY // 6
};By default, the first value is 0, and each subsequent value increments by 1.
Basic Enum Example
Example
#include <stdio.h>
enum Season { SPRING, SUMMER, AUTUMN, WINTER };
int main() {
enum Season current = AUTUMN;
printf("Season value: %d\n", current);
switch (current) {
case SPRING: printf("It's spring!\n"); break;
case SUMMER: printf("It's summer!\n"); break;
case AUTUMN: printf("It's autumn!\n"); break;
case WINTER: printf("It's winter!\n"); break;
}
return 0;
}
Output
Season value: 2 It's autumn!
Custom Enum Values
You can assign specific values to enum constants:
c example
#include <stdio.h>
enum HttpStatus {
OK = 200,
CREATED = 201,
BAD_REQUEST = 400,
NOT_FOUND = 404,
SERVER_ERROR = 500
};
int main() {
enum HttpStatus response = NOT_FOUND;
printf("Status code: %d\n", response);
if (response >= 400) {
printf("Error response!\n");
}
return 0;
}Output
Status code: 404 Error response!
Mixed Custom and Auto Values
c example
enum Priority {
LOW = 1,
MEDIUM, // 2 (auto-increments from 1)
HIGH, // 3
CRITICAL = 10,
EMERGENCY // 11 (auto-increments from 10)
};Enum vs #define — When to Use Which
| Feature | enum | #define |
|---|---|---|
| Type safety | Yes (enum type) | No (just text replacement) |
| Debugging | Shows name in debugger | Shows raw number |
| Scope | Follows C scoping rules | Global (until #undef) |
| Auto-increment | Yes (0, 1, 2...) | No |
| Groups related constants | Yes | Not inherently |
| Can use in switch | Yes (compiler warns if case missed) | Yes |
c example
// #define approach
#define COLOR_RED 0
#define COLOR_GREEN 1
#define COLOR_BLUE 2
// enum approach (preferred)
enum Color { RED, GREEN, BLUE };
// enum is better because:
// 1. Groups constants logically
// 2. Debugger shows "RED" not "0"
// 3. Compiler can warn about missing switch casesEnum with Bit Flags
c example
#include <stdio.h>
enum Permission {
PERM_READ = 1, // 001
PERM_WRITE = 2, // 010
PERM_EXECUTE = 4 // 100
};
int main() {
// Combine permissions with bitwise OR
int user_perms = PERM_READ | PERM_WRITE; // 011 = 3
int admin_perms = PERM_READ | PERM_WRITE | PERM_EXECUTE; // 111 = 7
printf("User permissions: %d\n", user_perms);
printf("Admin permissions: %d\n", admin_perms);
// Check specific permission with AND
if (user_perms & PERM_WRITE) {
printf("User can write\n");
}
if (!(user_perms & PERM_EXECUTE)) {
printf("User cannot execute\n");
}
return 0;
}Output
User permissions: 3 Admin permissions: 7 User can write User cannot execute
Enum in State Machines
Example
#include <stdio.h>
enum TrafficLight { RED, YELLOW, GREEN };
const char *light_name(enum TrafficLight light) {
switch (light) {
case RED: return "RED";
case YELLOW: return "YELLOW";
case GREEN: return "GREEN";
default: return "UNKNOWN";
}
}
enum TrafficLight next_state(enum TrafficLight current) {
switch (current) {
case RED: return GREEN;
case GREEN: return YELLOW;
case YELLOW: return RED;
default: return RED;
}
}
int main() {
enum TrafficLight light = RED;
for (int i = 0; i < 6; i++) {
printf("Light: %s\n", light_name(light));
light = next_state(light);
}
return 0;
}
Output
Light: RED Light: GREEN Light: YELLOW Light: RED Light: GREEN Light: YELLOW
Enum Size and Type
c example
#include <stdio.h>
enum Small { A, B, C };
enum Large { X = 1000000000 };
int main() {
printf("sizeof(enum Small): %zu\n", sizeof(enum Small));
printf("sizeof(enum Large): %zu\n", sizeof(enum Large));
printf("sizeof(int): %zu\n", sizeof(int));
// Enums are always int-sized in C
return 0;
}Output
sizeof(enum Small): 4 sizeof(enum Large): 4 sizeof(int): 4
In C, enums are always stored as int (4 bytes typically), regardless of the values they hold.
Practical Example: Menu System
Example
#include <stdio.h>
enum MenuChoice {
MENU_ADD = 1,
MENU_DELETE,
MENU_SEARCH,
MENU_DISPLAY,
MENU_EXIT
};
int main() {
int choice;
printf("=== Student Management ===\n");
printf("1. Add Student\n");
printf("2. Delete Student\n");
printf("3. Search Student\n");
printf("4. Display All\n");
printf("5. Exit\n");
printf("Enter choice: ");
scanf("%d", &choice);
switch ((enum MenuChoice)choice) {
case MENU_ADD:
printf("Adding student...\n"); break;
case MENU_DELETE:
printf("Deleting student...\n"); break;
case MENU_SEARCH:
printf("Searching...\n"); break;
case MENU_DISPLAY:
printf("Displaying all...\n"); break;
case MENU_EXIT:
printf("Goodbye!\n"); break;
default:
printf("Invalid choice!\n");
}
return 0;
}
Output
=== Student Management === 1. Add Student 2. Delete Student 3. Search Student 4. Display All 5. Exit Enter choice: 3 Searching...
Interview Questions
Q1: What is the default value of the first enum constant?
The first constant is 0, and each subsequent constant increments by 1 unless explicitly assigned. You can override any constant with a custom value.
Q2: Can two enum constants have the same value?
Yes. enum { A = 1, B = 1 } is valid. This is sometimes used for aliases: enum { SUCCESS = 0, OK = 0 }.
Q3: What is the size of an enum variable in C?
In C, enum variables are always stored as int (typically 4 bytes), regardless of how few or small the values are. Some compilers offer extensions to use smaller types.
Q4: Can you use enums with arrays?
Yes, and it's a great pattern for readable code:
Example
enum Color { RED, GREEN, BLUE, NUM_COLORS };
int counts[NUM_COLORS] = {0};
counts[RED] = 5; // Much more readable than counts[0]
Q5: Why prefer enum over #define for related constants?
Enums provide type safety (compiler warnings), debugger visibility (names vs numbers), logical grouping, and auto-incrementing values. #define has no type, no scope, and no grouping.
Summary
- Enums define a set of named integer constants
- Default values start at 0 and auto-increment
- Custom values can be assigned to any constant
- Prefer enums over
#definefor groups of related constants - Enums are excellent for switch statements, state machines, and flags
- Combine with bit flags using powers of 2 for permission systems
- In C, enum size is always
sizeof(int)
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Enums in C – Enumerated Data Types.
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, structures, and, unions, enums, enums in c – enumerated data types
Related C Programming Topics
Continue learning this concept
Structures And UnionsArrays of Structures in C – Managing CollectionsComplete guide to arrays of structures in C — declaring and initializing struct arrays, student database example, sorting, searching, passing to functions, practical examples with output.Structures And UnionsNested Structures in C – Struct Within StructComplete guide to nested structures in C — defining structures inside structures, accessing nested members, practical examples like address within employee, date within record, with output.Structures And UnionsPointers to Structures in C – Arrow OperatorComplete guide to pointers to structures in C — arrow operator (->), dynamic struct allocation, passing structs by pointer, linked list basics, practical examples with output.Structures And UnionsStructures in C – User-Defined Data TypesComplete guide to structures in C programming — definition, declaration, initialization, accessing members with dot operator, struct memory layout, size and padding, practical examples with output.Structures And Unionstypedef in C – Creating Type AliasesComplete guide to typedef in C programming — creating type aliases, typedef with structures, typedef with pointers and arrays, function pointer typedefs, improving code readability, practical examples.Structures And UnionsUnions in C – Shared Memory Data TypesComplete guide to unions in C programming — definition, syntax, shared memory concept, difference between struct and union, practical examples, type punning, tagged unions, and interview questions.