C Preprocessor Directives

• Preprocessor directives in C are commands executed before the compilation stage.
• These directives instruct the preprocessor to modify source code before compilation.
• Preprocessor directives begin with a # symbol.
• They are used for tasks like including header files, defining macros, and conditional compilation.

Common Preprocessor Directives

• #include includes header files, which declare functions, variables, and other programming elements.
• Use #include <header_file.h> for standard library headers, and #include "header_file.h" for user-defined headers.
• #define defines macros; named constants or code snippets replaced by their value during preprocessing.
• Usage example: #define PI 3.14159.
• #undef undefines a macro, removing its definition, making it no longer available for replacement.
• Usage example: #undef PI.
• #ifdef, #ifndef, #if, #else, #elif, and #endif are for conditional compilation, allowing code inclusion/exclusion based on conditions.
• #ifdef checks if a macro is defined.
• #ifndef checks if a macro is not defined.
• #if checks if a constant expression is true.
• #else provides an alternative code block if the preceding #if, #ifdef, or #ifndef condition is false.
• #elif combines #else and #if to check multiple conditions.
• #endif marks the end of a conditional block.
• #error generates a compilation error, halting compilation & displaying a custom error message if a condition is met.
• Usage example: #error "This code section is not supported".
• #pragma issues special compiler commands, controlling aspects like optimization, warning levels, and memory management; it is compiler-specific
• Usage example: #pragma once prevents multiple inclusions of a header file.

Macro Definition

• Macros can be simple constants or complex code snippets.
• #define MAX(a, b) ((a) > (b) ? (a) : (b)) defines a macro returning the maximum of two values.
• Macros can accept arguments substituted into the macro's definition during preprocessing.
• Macro names are typically uppercase to distinguish them from variables.
• Macros lack type checking, requiring cautious usage.

Conditional Compilation

• Conditional compilation includes/excludes code sections based on specific conditions.
• It is useful for debugging, including debugging code only when a debug macro is defined
• Enables platform-specific code, including different code sections for different operating systems or hardware platforms.
• Permits feature toggles, enabling/disabling features based on a configuration macro.
• Example:

#ifdef DEBUG
    printf("Debugging information: variable x = %d\n", x);
#endif

• The printf statement is included in the compiled code only if the DEBUG macro is defined.

Header Files

• Header files declare functions, variables, and other programming elements used in multiple source files.
• Including header files promotes code reuse and avoids duplication.
• Standard library header files (e.g., stdio.h, stdlib.h, math.h) provide access to common functions and data types.
• User-defined header files organize and share code within a project.
• Header files typically contain function prototypes, structure/union/enum declarations, macro definitions, type definitions (using typedef), and global variable declarations (with extern).
• Include guards in header files prevent multiple inclusions, and are implemented using conditional compilation:

#ifndef HEADER_FILE_H
#define HEADER_FILE_H

// Header file content

#endif

• This code ensures a header file is included only once, even with multiple inclusions in different source files.

Predefined Macros

• The C preprocessor defines several predefined macros that provide information about the compilation environment.
• __LINE__: Expands to the current line number in the source code file.
• __FILE__: Expands to the name of the current source code file.
• __DATE__: Expands to the current date as a string literal in "Mmm dd yyyy" format.
• __TIME__: Expands to the current time as a string literal in "hh:mm:ss" format.
• __STDC__: Defined as 1 if the compiler conforms to the ANSI C standard.
• These macros are leveraged for debugging, logging, and other purposes.

Using Pragmas

• #pragma directives are compiler-specific, controlling various aspects of the compilation process.
• #pragma once prevents multiple header file inclusions, serving as an alternative to include guards.
• #pragma pack controls the memory alignment of structures and unions.
• Other pragmas for optimization, warning levels, and code generation may be available depending on the compiler.
• Using #pragma directives can reduce code portability as they are not standardized across compilers.

Order of Preprocessing

• The preprocessor performs operations in a specific order:
• Inclusion of header files (#include).
• Macro expansion (#define).
• Conditional compilation (#ifdef, #ifndef, #if, etc.).
• Other directives (#error, #pragma, etc.).
• Understanding the order of preprocessing is important for understanding how preprocessor directives affect the compiled code.

Examples of Preprocessor Directives in Action

• Simple Macro Definition:

#define ARRAY_SIZE 100
int myArray[ARRAY_SIZE]; // myArray will be an array of 100 integers

• Conditional Compilation for Debugging:

#define DEBUG // Define the DEBUG macro

#ifdef DEBUG
#include <stdio.h>
#define DEBUG_PRINT(fmt, args...) printf("DEBUG: " fmt, ##args)
#else
#define DEBUG_PRINT(fmt, args...) /* Do nothing */
#endif

int main() {
    int x = 5;
    DEBUG_PRINT("Value of x is %d\n", x); // This line will be compiled only if DEBUG is defined
    return 0;
}

• Include Guards in a Header File:

// myheader.h
#ifndef MYHEADER_H
#define MYHEADER_H

// Function declarations
int add(int a, int b);

#endif

• Using #error for Compile-Time Checks:

#define OS_WINDOWS 1
#define OS_LINUX 2

#ifndef OS
#error "OS must be defined! Define either OS_WINDOWS or OS_LINUX"
#endif

#if OS != OS_WINDOWS && OS != OS_LINUX
#error "Invalid OS value! OS must be either OS_WINDOWS or OS_LINUX"
#endif