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 macro functions in C — parameterized macros, variadic macros, do-while trick, inline comparison with macros, safe macro patterns, debugging macros, practical examples.
Function-like macros look like function calls but are expanded by the preprocessor as inline text. They have zero overhead (no function call), work with any type (generic), but come with pitfalls that require careful engineering. This guide covers advanced macro techniques and safe patterns.
Basic Parameterized Macros
c example
#define ADD(a, b) ((a) + (b))
#define SQUARE(x) ((x) * (x))
#define IS_EVEN(n) (((n) % 2) == 0)
#define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
#define TO_LOWER(c) ((c) + 32)Example
#include <stdio.h>
#define CIRCLE_AREA(r) (3.14159 * (r) * (r))
#define CELSIUS_TO_F(c) (((c) * 9.0 / 5.0) + 32.0)
#define IS_LEAP(y) (((y)%4==0 && (y)%100!=0) || (y)%400==0)
int main() {
printf("Circle area (r=5): %.2f\n", CIRCLE_AREA(5));
printf("100°C = %.1f°F\n", CELSIUS_TO_F(100));
printf("2024 leap? %s\n", IS_LEAP(2024) ? "Yes" : "No");
printf("2023 leap? %s\n", IS_LEAP(2023) ? "Yes" : "No");
return 0;
}
Output
Circle area (r=5): 78.54 100°C = 212.0°F 2024 leap? Yes 2023 leap? No
The do { ... } while(0) Trick
The most important technique for multiline macros:
c example
// PROBLEM: This macro breaks with if/else
#define BAD_SWAP(a, b) { int t = (a); (a) = (b); (b) = t; }
if (condition)
BAD_SWAP(x, y); // Expands to { ... }; ← extra semicolon!
else // ERROR: "else without matching if"
something_else();
// SOLUTION: do-while(0) wrapping
#define SWAP(a, b) do { \
int t = (a); \
(a) = (b); \
(b) = t; \
} while(0)
if (condition)
SWAP(x, y); // Works perfectly!
else
something_else();Why it works:
do { ... } while(0)is a single statement- The semicolon after the macro call terminates the do-while
- No dangling semicolons that break if/else
Type-Generic Macros
Macros work with any type — they're like templates:
c example
#include <stdio.h>
// Works with int, float, double, char...
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
// Type-safe swap using typeof (GCC extension)
#define TYPED_SWAP(a, b) do { \
typeof(a) _temp = (a); \
(a) = (b); \
(b) = _temp; \
} while(0)
int main() {
// Works with integers
printf("MAX(3, 7) = %d\n", MAX(3, 7));
// Works with floats
printf("MIN(3.14, 2.71) = %.2f\n", MIN(3.14, 2.71));
// Works with chars
printf("MAX('a', 'z') = %c\n", MAX('a', 'z'));
int x = 10, y = 20;
TYPED_SWAP(x, y);
printf("After swap: x=%d, y=%d\n", x, y);
return 0;
}Output
MAX(3, 7) = 7
MIN(3.14, 2.71) = 2.71
MAX('a', 'z') = z
After swap: x=20, y=10Variadic Macros (__VA_ARGS__)
Macros that accept a variable number of arguments (C99):
Example
#include <stdio.h>
// Basic variadic macro
#define PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
// Debug macro with file/line info
#define DEBUG(fmt, ...) \
fprintf(stderr, "[DEBUG %s:%d] " fmt "\n", \
__FILE__, __LINE__, ##__VA_ARGS__)
// LOG macro with level
#define LOG(level, fmt, ...) \
printf("[%-5s] " fmt "\n", level, ##__VA_ARGS__)
int main() {
int users = 42;
float uptime = 99.9;
LOG("INFO", "Server started with %d users", users);
LOG("WARN", "Memory at 80%% capacity");
LOG("ERROR", "Connection timeout after %.1fs", uptime);
DEBUG("Variable users = %d", users);
return 0;
}
Output
[INFO ] Server started with 42 users [WARN ] Memory at 80% capacity [ERROR] Connection timeout after 99.9s [DEBUG main.c:19] Variable users = 42
The ##__VA_ARGS__ (GCC extension) removes the trailing comma when no extra arguments are passed.
Macro vs Inline Function
| Feature | Macro | inline Function |
|---|---|---|
| Type checking | None | Full |
| Side effects | Double evaluation | Single evaluation |
| Debugging | Hard (expanded text) | Normal |
| Code size | Duplicated everywhere | Compiler decides |
| Type generic | Naturally | No (needs separate functions) |
| Recursion | Not possible | Possible |
| Overhead | Zero | Zero (if truly inlined) |
c example
// Macro version — type generic, but unsafe with side effects
#define MAX_MACRO(a, b) ((a) > (b) ? (a) : (b))
// Inline version — type safe, but only for int
static inline int max_inline(int a, int b) {
return a > b ? a : b;
}Advanced Pattern: Assert Macro
c example
#include <stdio.h>
#include <stdlib.h>
#define ASSERT(condition) do { \
if (!(condition)) { \
fprintf(stderr, "ASSERTION FAILED: %s\n", #condition); \
fprintf(stderr, " File: %s, Line: %d\n", __FILE__, __LINE__); \
abort(); \
} \
} while(0)
int main() {
int x = 5;
ASSERT(x > 0); // Passes
ASSERT(x < 10); // Passes
// ASSERT(x > 100); // Would print: ASSERTION FAILED: x > 100
printf("All assertions passed!\n");
return 0;
}Output
All assertions passed!
Advanced Pattern: Error Handling
Example
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#define CHECK_NULL(ptr, msg) do { \
if ((ptr) == NULL) { \
fprintf(stderr, "Error: %s (file: %s, line: %d)\n", \
msg, __FILE__, __LINE__); \
exit(EXIT_FAILURE); \
} \
} while(0)
#define SAFE_MALLOC(ptr, size) do { \
(ptr) = malloc(size); \
CHECK_NULL(ptr, "Memory allocation failed"); \
} while(0)
int main() {
int *data;
SAFE_MALLOC(data, 100 * sizeof(int));
data[0] = 42;
printf("Allocated and used successfully: %d\n", data[0]);
free(data);
return 0;
}
Output
Allocated and used successfully: 42
Macro for Unit Testing
Example
#include <stdio.h>
static int tests_passed = 0;
static int tests_failed = 0;
#define TEST_EQUAL(actual, expected) do { \
if ((actual) == (expected)) { \
tests_passed++; \
} else { \
tests_failed++; \
printf("FAIL: %s == %s (got %d, expected %d) at line %d\n", \
#actual, #expected, (actual), (expected), __LINE__); \
} \
} while(0)
#define TEST_SUMMARY() \
printf("\nResults: %d passed, %d failed\n", tests_passed, tests_failed)
int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }
int main() {
TEST_EQUAL(add(2, 3), 5);
TEST_EQUAL(add(-1, 1), 0);
TEST_EQUAL(mul(3, 4), 12);
TEST_EQUAL(mul(0, 100), 0);
TEST_EQUAL(add(2, 2), 5); // This will fail
TEST_SUMMARY();
return 0;
}
Output
FAIL: add(2, 2) == 5 (got 4, expected 5) at line 28 Results: 4 passed, 1 failed
Interview Questions
Q1: Why use do { ... } while(0) for multiline macros?
It makes the macro behave like a single statement that requires a semicolon. Without it, macros in if/else without braces break because of dangling semicolons or missing statement grouping. The while(0) is always false so the loop runs exactly once.
Q2: What is __VA_ARGS__ and when do you use it?
__VA_ARGS__ represents the variable arguments passed to a variadic macro (defined with ...). It's used for printf-like macros: #define LOG(fmt, ...) printf(fmt, __VA_ARGS__). The ## prefix handles the case when no variable arguments are passed (removes trailing comma).
Q3: When should you use a macro instead of an inline function?
Use macros when you need type-generic behavior (works with any type without overloads), compile-time code generation (token pasting, stringification), or when the pattern involves multiple statements that reference the caller's scope (like a SWAP that modifies the caller's variables).
Q4: How do you prevent naming conflicts in macro variables?
Use unusual names with underscores or prefixes: _temp_##__LINE__. In GCC, use __typeof__ and statement expressions ({...}) for safe temporary variables. Some codebases use __macro_var_ prefixes to avoid conflicts with user code.
Summary
- Function-like macros provide zero-overhead inline expansion
- Always wrap in
do { ... } while(0)for multiline safety - Always parenthesize parameters and the entire expression
- Variadic macros (
__VA_ARGS__) enable printf-like interfaces - Use
#for stringification and##for token pasting - Macros are type-generic but have the double-evaluation pitfall
- Prefer inline functions when type safety matters more than genericity
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Macro Functions in C – Parameterized Macros.
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, macro, functions, macro functions in c – parameterized macros
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.Preprocessor#define Macros in C – Constants and Macro FunctionsComplete guide to #define macros in C — defining constants, function-like macros, macro pitfalls, multiline macros, stringification, token pasting, common patterns and best practices.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.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.ArraysPassing Arrays to Functions in CUnderstand how arrays are passed to functions in C, array decay to pointers, why size information is lost, and best practices for writing array-handling functions.