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 #define macros in C — defining constants, function-like macros, macro pitfalls, multiline macros, stringification, token pasting, common patterns and best practices.
The #define directive is the preprocessor's workhorse. It creates macros — named text substitutions that are expanded before compilation. From simple constants to complex function-like patterns, macros are powerful but need careful handling to avoid subtle bugs.
Simple Constants (Object-like Macros)
c example
#define PI 3.14159265358979
#define MAX_SIZE 1000
#define AUTHOR "Dennis Ritchie"
#define TRUE 1
#define FALSE 0These perform simple text replacement:
c example
#include <stdio.h>
#define TAX_RATE 0.18
#define COMPANY "TechCorp"
#define VERSION 2
int main() {
double price = 1000.0;
double tax = price * TAX_RATE;
double total = price + tax;
printf("%s Invoice (v%d)\n", COMPANY, VERSION);
printf("Price: $%.2f\n", price);
printf("Tax (%.0f%%): $%.2f\n", TAX_RATE * 100, tax);
printf("Total: $%.2f\n", total);
return 0;
}Output
TechCorp Invoice (v2) Price: $1000.00 Tax (18%): $180.00 Total: $1180.00
#define vs const — When to Use Which
| Feature | #define | const |
|---|---|---|
| Processed by | Preprocessor | Compiler |
| Type checking | None | Yes |
| Memory | No storage | Variable in memory |
| Scope | Global (until #undef) | Follows C scope |
| Debugger | Shows value only | Shows name and value |
| Can be used for | Anything (types, code) | Values only |
| Array sizes (C89) | Yes | No (use VLA or #define) |
Example
// For numeric constants — prefer const (type-safe)
const int MAX_STUDENTS = 100;
const double PI = 3.14159;
// For these cases — must use #define:
#define ARRAY_SIZE 50 // Array dimension in C89
int arr[ARRAY_SIZE]; // const can't do this in C89
#define PLATFORM "linux" // String constants
#define UNUSED __attribute__((unused)) // Compiler attributes
Function-like Macros
c example
#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define ABS(x) ((x) < 0 ? -(x) : (x))
#define SWAP(a, b, type) { type temp = (a); (a) = (b); (b) = temp; }c example
#include <stdio.h>
#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define CLAMP(val, lo, hi) (MAX(lo, MIN(val, hi)))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
int main() {
printf("SQUARE(5) = %d\n", SQUARE(5));
printf("MAX(10, 20) = %d\n", MAX(10, 20));
printf("CLAMP(150, 0, 100) = %d\n", CLAMP(150, 0, 100));
printf("CLAMP(-5, 0, 100) = %d\n", CLAMP(-5, 0, 100));
return 0;
}Output
SQUARE(5) = 25 MAX(10, 20) = 20 CLAMP(150, 0, 100) = 100 CLAMP(-5, 0, 100) = 0
The Parentheses Problem — #1 Macro Pitfall
c example
// WRONG — missing parentheses
#define DOUBLE(x) x * 2
int result = DOUBLE(3 + 1);
// Expands to: 3 + 1 * 2 = 3 + 2 = 5 (WRONG! Expected 8)
// CORRECT — always wrap parameters AND the whole expression
#define DOUBLE(x) ((x) * 2)
int result = DOUBLE(3 + 1);
// Expands to: ((3 + 1) * 2) = 8 (CORRECT)Rule: Always parenthesize:
- Each parameter usage:
(x) - The entire macro body:
((x) * (x))
The Double-Evaluation Problem
Example
#include <stdio.h>
#define MAX(a, b) ((a) > (b) ? (a) : (b))
int main() {
int x = 5, y = 3;
// This evaluates x++ TWICE if x > y!
int result = MAX(x++, y++);
// Expands to: ((x++) > (y++) ? (x++) : (y++))
// x gets incremented twice!
printf("result = %d, x = %d, y = %d\n", result, x, y);
// Unexpected behavior!
return 0;
}
Output
result = 6, x = 7, y = 4
Lesson: Never pass expressions with side effects (++, --, function calls) to function-like macros.
Multiline Macros
Example
#include <stdio.h>
#define PRINT_HEADER(title) \
printf("========================\n"); \
printf(" %s\n", title); \
printf("========================\n")
#define LOG(level, msg) do { \
printf("[%s] %s:%d - %s\n", level, __FILE__, __LINE__, msg); \
} while(0)
int main() {
PRINT_HEADER("My Program");
LOG("INFO", "Program started");
LOG("WARN", "Low memory");
return 0;
}
Output
======================== My Program ======================== [INFO] main.c:13 - Program started [WARN] main.c:14 - Low memory
Stringification (#) and Token Pasting (##)
c example
#include <stdio.h>
// # converts argument to string literal
#define STRINGIFY(x) #x
#define PRINT_EXPR(expr) printf(#expr " = %d\n", (expr))
// ## concatenates tokens to form new identifiers
#define DECLARE_VAR(type, name) type var_##name
#define GETTER(field) get_##field()
int main() {
printf("%s\n", STRINGIFY(Hello World)); // "Hello World"
int x = 10, y = 20;
PRINT_EXPR(x + y); // printf("x + y" " = %d\n", (x + y));
PRINT_EXPR(x * y);
DECLARE_VAR(int, count) = 42; // int var_count = 42;
printf("var_count = %d\n", var_count);
return 0;
}Output
Hello World x + y = 30 x * y = 200 var_count = 42
#undef — Removing a Macro
c example
#define BUFFER_SIZE 1024
// ... use BUFFER_SIZE ...
#undef BUFFER_SIZE // Remove the definition
#define BUFFER_SIZE 4096 // Redefine with new valueConditional Definition
c example
// Define only if not already defined (safe default)
#ifndef MAX_RETRIES
#define MAX_RETRIES 3
#endif
// Allow override from command line:
// gcc -DMAX_RETRIES=5 program.cCommon Macro Patterns
Example
// Array size (works for stack arrays, not pointers!)
#define ARRAY_LEN(arr) (sizeof(arr) / sizeof((arr)[0]))
// Bit manipulation
#define SET_BIT(x, bit) ((x) |= (1 << (bit)))
#define CLEAR_BIT(x, bit) ((x) &= ~(1 << (bit)))
#define CHECK_BIT(x, bit) ((x) & (1 << (bit)))
// Memory alignment
#define ALIGN_UP(x, align) (((x) + (align) - 1) & ~((align) - 1))
// Debug printing
#ifdef DEBUG
#define DBG(fmt, ...) fprintf(stderr, "[DBG] " fmt "\n", ##__VA_ARGS__)
#else
#define DBG(fmt, ...) ((void)0)
#endif
Interview Questions
Q1: Why must you parenthesize macro parameters?
Without parentheses, operator precedence can produce wrong results. #define MUL(a,b) a*b — calling MUL(2+3, 4) expands to 2+3*4 = 14 (not 20). With ((a)*(b)) it correctly gives ((2+3)*(4)) = 20.
Q2: What is the double-evaluation problem in macros?
When a macro argument has side effects (like x++), it gets evaluated multiple times because it appears multiple times in the expansion. MAX(x++, y) might increment x twice. Functions don't have this problem because arguments are evaluated once.
Q3: What's the difference between #define and typedef?
#define is text substitution (preprocessor), typedef creates a type alias (compiler). #define can replace any text, typedef only creates type names. typedef respects scope and handles pointers correctly. Use typedef for types, #define for constants and code patterns.
Q4: How do you write a safe multiline macro?
Wrap it in do { ... } while(0). This makes the macro behave like a single statement, works correctly with if/else without braces, and requires a semicolon after use — just like a function call.
Summary
#defineperforms text substitution before compilation- Always parenthesize parameters AND the full macro body
- Beware of double-evaluation with side-effect arguments
- Use
do { ... } while(0)for multiline macros #stringifies,##concatenates tokens- Prefer
constfor type-safe numeric constants - Use
#definewhen you need compile-time array sizes, platform macros, or code generation
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for #define Macros in C – Constants and Macro Functions.
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, preprocessor, define, macros, #define macros in c – constants and macro functions
Related C Programming Topics
Continue learning this concept
PreprocessorConditional Compilation in C – #ifdef, #ifndef, #ifComplete guide to conditional compilation in C — #ifdef, #ifndef, #if, #elif, #else, #endif directives, platform-specific code, debug builds, feature toggles, practical examples.PreprocessorHeader Files in C – Creating Custom HeadersComplete guide to creating custom header files in C — what goes in a header, include guards, separating declaration from definition, multi-file projects, best practices, practical examples.Preprocessor#include Directive in C – File InclusionComplete guide to #include in C — angle brackets vs quotes, header file search paths, header guards, preventing multiple inclusion, system vs user headers, practical examples.PreprocessorMacro Functions in C – Parameterized MacrosComplete guide to macro functions in C — parameterized macros, variadic macros, do-while trick, inline comparison with macros, safe macro patterns, debugging macros, practical examples.PreprocessorC Preprocessor – Overview and DirectivesComplete guide to the C preprocessor — what it is, how it works, preprocessing stages, all preprocessor directives overview, #pragma, #error, #line, predefined macros, practical examples.Advanced CC Programming Best Practices – Coding Standards, Safety, and PerformanceLearn essential C programming best practices covering coding standards, memory safety, error handling, performance optimization, and writing maintainable C code.