🛠️ 23. Advanced C Preprocessor

The C preprocessor is a program that processes source code before the actual C compilation stage. It handles directives such as #include, #define, conditional compilation, macro expansion, and several compiler-provided predefined macros.

You already learned the fundamentals of preprocessing and header files. This topic goes deeper into the techniques used in real C projects: function-like macros, token pasting, stringification, variadic macros, conditional compilation, feature detection, include guards, predefined macros, debugging, and macro safety.

23.1 What Happens Before Compilation?

 C source file | ▼ Preprocessor | ├── #include ├── #define ├── #if / #ifdef ├── macro expansion └── conditional removal | ▼ Preprocessed translation unit | ▼ Compiler | ▼ Object code | ▼ Linker | ▼ Executable 

Macro replacement works with token sequences, not runtime variable values. The compiler checks types and expression rules after preprocessing has produced the source it will translate.

23.2 Object-Like Macros

An object-like macro has an identifier followed by a replacement list.

#define PI 3.14159
#define MAX_STUDENTS 100
#define COMPANY_NAME "CodeBhavya"

Whenever the macro identifier is encountered in an appropriate preprocessing context, it can be replaced by its replacement list.

23.3 Function-Like Macros

A function-like macro is defined using parentheses immediately after the macro name.

#define SQUARE(x) ((x) * (x))

Example:

int result = SQUARE(5);

After macro expansion, the compiler effectively sees:

int result = ((5) * (5));

23.4 Why Parentheses Matter in Macros

Unsafe macro:

#define SQUARE(x) x * x

Consider:

int result = SQUARE(2 + 3);

Expansion becomes:

2 + 3 * 2 + 3

Because multiplication has higher precedence, this does not mean (2 + 3) * (2 + 3).

Safer form:

#define SQUARE(x) ((x) * (x))

23.5 The Double-Parentheses Rule

For a simple expression macro, a strong general pattern is:

#define NAME(parameter) ((parameter) expression (parameter))

For example:

#define DOUBLE(x) ((x) * 2)
#define ABS(x) (((x) < 0) ? -(x) : (x))
#define MAX(a, b) (((a) > (b)) ? (a) : (b))

Put parentheses around each parameter use and around the whole expression. These protect grouping; they do not protect against repeated evaluation.

23.6 Macro Arguments Are Not Evaluated Like Function Arguments

Consider:

#define SQUARE(x) ((x) * (x))
int i = 5;
int result = SQUARE(i++);

Expansion is conceptually:

((i++) * (i++))

Here the expanded multiplication contains i++ twice without a guaranteed order between the changes. Its behavior is undefined. Do not guess a numeric output for this example.

23.7 Macro vs Function

23.8 The Stringification Operator #

The preprocessor provides the # operator inside a macro replacement list to convert a macro argument into a string literal.

#define SHOW_NAME(x) printf(#x "\n")

Then:

SHOW_NAME(CodeBhavya);

produces code equivalent in effect to:

printf("CodeBhavya" "\n");

23.9 Stringification Example

#include <stdio.h>

#define SHOW_VALUE(x) \
    printf("%s = %d\n", #x, (x))

int main(void)
{
    int marks = 95;
    SHOW_VALUE(marks);
    return 0;
}

Output:

marks = 95

23.10 Important Stringification Behavior

The # With #x, the argument spelling is turned into a string rather than evaluated. If x is itself a macro name, direct stringification does not first expand that argument. Use a helper macro when you want the expanded value’s spelling.

#define TRACE_VALUE(x) \
    printf("%s = %d\n", #x, (x))

23.11 The Token-Pasting Operator ##

The ## operator joins two preprocessing tokens.

#define JOIN(a, b) a ## b

For example:

int JOIN(student, 1) = 90;

can produce an identifier equivalent to:

int student1 = 90;

23.12 Token Pasting Example

#include <stdio.h>

#define MAKE_NAME(prefix, number) prefix ## number

int main(void)
{
    int student1 = 95;
    printf("%d\n", MAKE_NAME(student, 1));
    return 0;
}

Output:

95

23.13 Stringification vs Token Pasting

 Macro argument | +---- # ----► string | +---- ## ---► combined token 

23.14 Two-Level Macro Expansion

Direct # and ## use keeps the corresponding argument from the usual expansion before that operation. A second macro layer can request expansion first.

A common helper pattern is:

#define CAT(a, b) CAT_IMPL(a, b)
#define CAT_IMPL(a, b) a ## b

This two-level structure allows an argument to be expanded before it is pasted in situations where direct ## use would inhibit that expansion.

23.15 Variadic Macros

Modern C supports variadic macros using ... and __VA_ARGS__.

#define LOG(...) printf(__VA_ARGS__)

Usage:

LOG("Hello %s\n", "C");

This is useful when the number of arguments varies.

23.16 Practical Variadic Logging Macro

#include <stdio.h>

#define LOG(fmt, ...) \
    printf("[LOG] " fmt "\n", __VA_ARGS__)

int main(void)
{
    int score = 95;
    LOG("Score = %d", score);
    return 0;
}

The LOG(fmt, ...) example needs at least one extra argument in C17. LOG("Score = %d", score) fits that form; LOG("Ready") does not. The LOG(...) form can accept a format string alone because that string is itself a variadic argument.

23.17 Conditional Compilation

These conditions select which source is compiled, rather than which branch runs each time the program executes. A macro can be defined by the source or by a build option.

#if CONDITION
/* compiled when CONDITION is true */
#endif

Common directives include:

• #if
• #ifdef
• #ifndef
• #elif
• #else
• #endif

23.18 #ifdef

#ifdef tests whether a macro is defined.

#define DEBUG
#ifdef DEBUG
printf("Debug mode\n");
#endif

23.19 #ifndef

#ifndef tests whether a macro is not defined.

#ifndef VALUE
#define VALUE 100
#endif

23.20 #if and Numeric Conditions

#define VERSION 3
#if VERSION >= 3
printf("Version 3 or later\n");
#else
printf("Older version\n");
#endif

The condition is evaluated during preprocessing.

23.21 #elif

#if defined(WINDOWS)
printf("Windows\n");
#elif defined(LINUX)
printf("Linux\n");
#else
printf("Other platform\n");
#endif

This is useful when source code must support multiple environments.

23.22 defined Operator

Inside a preprocessing conditional expression, defined can test whether a macro exists.

#if defined(DEBUG)
printf("Debug enabled\n");
#endif

It can also be written as:

#if defined DEBUG
printf("Debug enabled\n");
#endif

23.23 Feature Flags

Conditional compilation can implement feature switches.

#define ENABLE_LOGGING
#ifdef ENABLE_LOGGING
#define LOG(message) printf("%s\n", message)
#else
#define LOG(message)
#endif

When logging is disabled, the macro expands to nothing.

23.24 Debug and Release Builds

A common project technique is to compile diagnostic code only in development builds.

#ifdef DEBUG
#define DEBUG_PRINT(x) printf("DEBUG: %s\n", x)
#else
#define DEBUG_PRINT(x)
#endif

The build system can define DEBUG using compiler options instead of modifying the source file.

23.25 Predefined Macros

The C implementation provides several useful predefined macros.

23.26 __FILE__ and __LINE__

#include <stdio.h>

int main(void)
{
    printf("File: %s\n", __FILE__);
    printf("Line: %d\n", __LINE__);
    return 0;
}

These macros help a diagnostic identify where it came from. Their values describe the source location, not a line currently typed by the user.

23.27 Building a Diagnostic Macro

#include <stdio.h>

#define REPORT(message) \
    printf("File: %s | Line: %d | %s\n", \
           __FILE__, __LINE__, message)

int main(void)
{
    REPORT("Program started");
    return 0;
}

23.28 __func__

__func__ is a predefined identifier provided inside functions. It is not a preprocessor macro.

#include <stdio.h>

void test(void)
{
    printf("Function: %s\n", __func__);
}

23.29 Include Guards

A guard prevents its header contents from being processed twice in one translation unit. It does not prevent an ordinary external variable definition in a header from being duplicated across different source files.

#ifndef STUDENT_H
#define STUDENT_H

typedef struct { int id; char name[50]; } Student;
void printStudent(Student student);

#endif

23.30 Why Include Guards Matter

Suppose several source files indirectly include the same header:

 main.c | +---- student.h | +---- college.h | +---- student.h Without guard: student.h may be processed repeatedly With guard: first inclusion → contents included later inclusion → contents skipped 

23.31 #pragma once

Many compilers support:

#pragma once

as a convenient way to request one-time inclusion of a header.

A conventional guard uses standard directives. #pragma once is widely supported, but it is a compiler feature rather than an ISO C directive with the same portable guarantee.

#ifndef MY_HEADER_H
#define MY_HEADER_H
/* declarations */
#endif

#pragma once

23.32 Header File Design

A well-designed header usually contains declarations, type definitions, macros that form part of the interface, and other information required by users of the module.

Keep private helper functions and ordinary object definitions in the source file where appropriate. A widely included header should not give each translation unit another external definition of the same object.

23.33 Conditional Header Content

#ifndef CB_CONFIG_H
#define CB_CONFIG_H
#define CB_VERSION_MAJOR 1
#define CB_VERSION_MINOR 0
#endif

This pattern prevents repeated inclusion and can also provide project-wide configuration information.

23.34 Compile-Time Assertions

Modern C provides _Static_assert for compile-time checks.

#include <limits.h>
_Static_assert(sizeof(int) >= 2, "int must be at least 2 bytes");

This is a language feature, not a preprocessor directive, but it is closely related to compile-time validation.

23.35 Compile-Time Configuration

Conditional preprocessing can select configuration-specific code.

#if defined(CB_SMALL_BUILD)
#define MAX_BUFFER 128
#else
#define MAX_BUFFER 1024
#endif

The build system can define CB_SMALL_BUILD when a smaller configuration is required.

23.36 Platform Selection

Large C applications sometimes need platform-specific implementations.

#if defined(_WIN32)
printf("Windows build\n");
#elif defined(__linux__)
printf("Linux build\n");
#elif defined(__APPLE__)
printf("Apple build\n");
#else
printf("Unknown platform\n");
#endif

23.37 Compiler Detection

Projects sometimes use compiler-specific predefined macros:

#if defined(__GNUC__)
printf("GNU-compatible compiler\n");
#endif

Such checks should be isolated carefully because compiler-specific branches can reduce portability.

23.38 Feature Detection vs Compiler Detection

When possible, it is better to determine whether the required feature exists rather than simply identifying a compiler.

Feature-oriented checks generally make portable code easier to maintain.

23.39 Macro Naming Conventions

Project-wide macros are commonly written in uppercase:

#define CB_MAX_STUDENTS 100
#define CB_ENABLE_LOGGING

A project-specific prefix reduces the chance of collisions with identifiers from libraries or other headers.

23.40 Reserved Macro Names

23.41 Multi-Line Macros

Place a backslash immediately before the newline to continue a directive. Do not put spaces after that backslash when writing portable source. The continued physical lines form one logical directive.

#define PRINT_SUM(a, b) \
    do { \
        printf("%d\n", (a) + (b)); \
    } while (0)

23.42 The do-while(0) Macro Pattern

Consider a macro containing multiple statements:

#define BAD_PRINT(x) printf("%d\n", x); printf("done\n");

Using it inside an if can produce surprising structure.

A safer multi-statement pattern is:

#define GOOD_PRINT(x) \
    do { \
        printf("%d\n", (x)); \
        printf("done\n"); \
    } while (0)

The wrapper makes the replacement act as one statement when the caller adds a semicolon. It does not automatically make repeated arguments or name collisions safe.

23.43 Macro Safety Example

if (condition) GOOD_PRINT(value); else printf("Other\n");

The do { ... } while (0) structure makes this usage much safer.

23.44 Macro Scope and Lifetime

A macro definition is active from its directive until #undef or the end of the translation unit. Braces around a C function or block do not create a local scope for that macro.

#define VALUE 100
printf("%d\n", VALUE);
#undef VALUE
/* VALUE is no longer defined here */

23.45 #undef

The #undef directive removes a macro definition.

#define SIZE 10
#undef SIZE
#define SIZE 20

After the second definition, SIZE expands to 20.

23.46 Redefining Macros

Macro redefinition should be done carefully.

#define VALUE 10
#define VALUE 20

Compilers can diagnose incompatible macro redefinitions. Avoid unnecessary redefinitions because they make code difficult to reason about.

23.47 Push/Pop Macro State

Some compilers provide non-standard pragmas for temporarily saving and restoring macro definitions.

Because these facilities are compiler-specific, portable C code should not depend on them without a clear platform requirement.

23.48 Macro Expansion Trace

#define VALUE 10
#define DOUBLE(x) ((x) * 2)
int result = DOUBLE(VALUE);

 DOUBLE(VALUE) | ▼ ((VALUE) * 2) | ▼ ((10) * 2) | ▼ 14? ← No | ▼ 20 

The important lesson is that macro expansion happens before normal compiler expression evaluation.

23.49 Nested Macros

#define BASE 10
#define DOUBLE(x) ((x) * 2)
#define RESULT DOUBLE(BASE)

Using:

int x = RESULT;

allows nested macro replacement to produce the final source expression.

23.50 Macro Constants vs const Variables

For typed constants, a const object or enumeration may often be clearer than a macro.

23.51 Macro Constants vs enum

#define RED 1
#define GREEN 2
#define BLUE 3

can sometimes be better represented by:

enum Color { RED, GREEN, BLUE };

The appropriate choice depends on the requirement.

23.52 Generic-Looking Macros

Macros can accept many kinds of expressions:

#define MAX(a, b) (((a) > (b)) ? (a) : (b))

This appears generic, but it has limitations because arguments can be evaluated more than once and the expressions may have unusual side effects or type interactions.

23.53 Advanced Macro Debugging

When a macro behaves unexpectedly, mentally perform these steps:

1. Write the macro definition.
2. Replace the macro call with the replacement list.
3. Substitute the arguments.
4. Check parentheses.
5. Check whether an argument appears more than once.
6. Then analyze the resulting C expression normally.

23.54 Macro Debugging Example

#define ADD(a, b) a + b
int result = ADD(10, 20) * 2;

Expansion:

10 + 20 * 2

Result:

50

Safer:

#define ADD(a, b) ((a) + (b))

Now:

((10) + (20)) * 2

Result:

60

23.55 Advanced Preprocessor Workflow

 Source Code | ▼ Identify # directives | ├── #include | └── insert header content | ├── #define | └── register macro | ├── macro call | └── expand replacement | ├── #if / #ifdef | └── choose source sections | └── #undef └── remove macro | ▼ Preprocessed source | ▼ Compiler 

23.56 Practical Example — Debug Logger

#include <stdio.h>

#ifdef DEBUG
#define LOG(message) \
    printf("[DEBUG] %s:%d: %s\n", \
           __FILE__, __LINE__, message)
#else
#define LOG(message) do { } while (0)
#endif

int main(void)
{
    LOG("Program started");
    printf("Application running\n");
    return 0;
}

This pattern demonstrates conditional compilation, predefined macros, and a safe empty macro branch.

23.57 Practical Example — Assertion-Like Macro

#include <stdio.h>

#define CB_REQUIRE(condition) \
    do { \
        if (!(condition)) { \
            printf("Requirement failed: %s\n", #condition); \
        } \
    } while (0)

int main(void)
{
    int age = 17;
    CB_REQUIRE(age >= 18);
    return 0;
}

Stringification allows the diagnostic to display the condition that failed.

23.58 Practical Example — Token Generation

#include <stdio.h>

#define CREATE_VARIABLE(prefix, number) prefix ## number

int main(void)
{
    int value1 = 100;
    printf("%d\n", CREATE_VARIABLE(value, 1));
    return 0;
}

The ## operator constructs the token value1.

23.59 Macro Pitfalls Checklist

#include <stdio.h>
#include <limits.h>

_Static_assert(CHAR_BIT >= 8, "At least eight bits per byte required");

int main(void)
{
    printf("Bits per byte: %d\n", CHAR_BIT);
    return 0;
}

23.61 Quick Revision

INTERACTIVE LEARNING

🎬 Advanced Preprocessor — Preprocessing Pipeline

Follow how directives, headers, macros and conditional compilation transform a C source file before normal compilation.

▶ Open Visualization

—

23.62 Quick MCQs

Select an answer first, then click Check Answer. A correct choice becomes green. If the answer is wrong, your choice becomes red and the correct option becomes green. The explanation appears below.

Run your program to see the output.

#include <stdio.h>

#define PI 3.141592653589793

int main()
{
    double r;
    scanf("%lf", &r);
    printf("%.2f", PI * r * r);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

#define SQUARE(x) ((x) * (x))

int main()
{
    int x;
    scanf("%d", &x);
    printf("%d", SQUARE(x));
    return 0;
}

Run your program to see the output.

#include <stdio.h>

#define BAD_SQUARE(x) x * x
#define GOOD_SQUARE(x) ((x) * (x))

int main()
{
    printf("Unsafe=%d\n", BAD_SQUARE(2 + 3));
    printf("Safe=%d", GOOD_SQUARE(2 + 3));
    return 0;
}

Run your program to see the output.

#include <stdio.h>

#define MAX(a,b) ((a) > (b) ? (a) : (b))

int main()
{
    int a, b;
    scanf("%d %d", &a, &b);
    printf("%d", MAX(a, b));
    return 0;
}

Run your program to see the output.

#include <stdio.h>

#define MIN(a,b) ((a) < (b) ? (a) : (b))

int main()
{
    int a, b;
    scanf("%d %d", &a, &b);
    printf("%d", MIN(a, b));
    return 0;
}

Run your program to see the output.

#include <stdio.h>

#define SHOW(x) printf("%s=%d", #x, (x))

int main()
{
    int marks;
    scanf("%d", &marks);
    SHOW(marks);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

#define CONCAT(a,b) a##b

int main()
{
    int value1;
    scanf("%d", &value1);
    printf("%d", CONCAT(value, 1));
    return 0;
}

Run your program to see the output.

#include <stdio.h>

#define INCREMENT_BOTH(a,b) \
    do {                     \
        (a)++;               \
        (b)++;               \
    } while (0)

int main()
{
    int x, y;
    scanf("%d %d", &x, &y);
    INCREMENT_BOTH(x, y);
    printf("%d %d", x, y);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

/* college.h concept */
#ifndef COLLEGE_H
#define COLLEGE_H
#define COLLEGE_NAME "CodeBhavya College"
#endif

int main()
{
    printf("%s", COLLEGE_NAME);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

#define DEBUG

int main()
{
#ifdef DEBUG
    printf("Debug mode");
#else
    printf("Release mode");
#endif
    return 0;
}

Run your program to see the output.

#include <stdio.h>

#define LEVEL 2

int main()
{
#if LEVEL == 1
    printf("Beginner");
#elif LEVEL == 2
    printf("Intermediate");
#else
    printf("Advanced");
#endif
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
#line 100 "demo.c"
    printf("%s", __FILE__);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
#line 700
    printf("%d", __LINE__);
    return 0;
}

Run your program to see the output.

#include <stdio.h>
#include <string.h>

int main()
{
    const char *dateText = __DATE__;
    const char *timeText = __TIME__;

    printf("DATE_LEN=%zu TIME_LEN=%zu",
           strlen(dateText), strlen(timeText));

    return 0;
}

Run your program to see the output.

#include <stdio.h>

#define DOUBLE(x) ((x) * 2)

int main()
{
    printf("%d", DOUBLE(2 + 3));
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("SQUARE(i++) is unsafe because the macro may evaluate i++ more than once.");
    return 0;
}

Run your program to see the output.

#include <stdio.h>

/* student.h concept */
#ifndef STUDENT_H
#define STUDENT_H
typedef struct
{
    int roll;
    float marks;
} Student;

void printStudent(Student s);
#endif

/* student.c concept */
void printStudent(Student s)
{
    printf("%d %.1f", s.roll, s.marks);
}

/* main.c concept */
int main()
{
    Student s;
    scanf("%d %f", &s.roll, &s.marks);
    printStudent(s);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

#define DEBUG_VAR(x) \
    printf("%s:%d %s=%d", __FILE__, __LINE__, #x, (x))

int main()
{
    int x;
    scanf("%d", &x);
#line 900 "debug_demo.c"
    DEBUG_VAR(x);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("Macro: preprocessing replacement.\n");
    printf("Function: compiled C code with typed parameters and return behavior.");
    return 0;
}

Run your program to see the output.

#include <stdio.h>

#define VALUE 10
#undef VALUE
#define VALUE 20

#define STRINGIZE(x) #x
#define CONCAT(a,b) a##b

#define FEATURE 1
#if FEATURE
#define FEATURE_TEXT "ON"
#else
#define FEATURE_TEXT "OFF"
#endif

int main()
{
    int item1 = 7;
#line 1000 "advanced_demo.c"
    printf("VALUE=%d FEATURE=%s NAME=%s TOKEN=%d FILE=%s LINE=%d",
           VALUE,
           FEATURE_TEXT,
           STRINGIZE(CodeBhavya),
           CONCAT(item, 1),
           __FILE__,
           __LINE__);
    return 0;
}

23.64 Interview Questions

23.65 Key Takeaway