Preprocessor Directives

Chapter-2
Dr. Chintan Thacker, Associate Professor
AI_ML Department, PIET
 Outline
File Inclusion
Macros CHAPTER-1
Conditional Compilation
Preprocessor Directives
Pragmas
What is PREPROCESSOR DIRECTIVES
• In C programming, Preprocessors are programs that process the source code before compilation. Several steps are
involved between writing a program and executing a program in C

• For example, “program.c” -> “program.obj” -> “program.exe”

PREPROCESSOR DIRECTIVES
• In C programming, Preprocessor Directives are special instructions given to the compiler to process your code before it
is compiled. Preprocessor directives always start with the # symbol. Think of them as setup commands that prepare your
code for the compiler.
• For example, they can include header files, define constants, or conditionally compile parts of your program.

• Here are some common examples:

• #include: Adds code from another file, like libraries.

• #define: Creates constants or macros.
• #ifdef / #ifndef: Checks if something is defined, for conditional
compilation.
PREPROCESSOR DIRECTIVES
• There are 4 main types of preprocessor directives:

1) Macros

2) File Inclusion

3) Conditional Compilation

4) Other Directives
What is File Inclusion?
• File inclusion is a way to add the content of one file into another using the #include directive.

• It is commonly used in programming to include header files, which contain important things.

Syntax: #include Typeyourfilename

• We can use a file inclusive directive and include the header files in the program

• We can integrate function declaration, macros, and declarations of the external variables in the top
header file
Types of File Inclusion
File inclusion in C/C++ can be of two types: Standard File Inclusion and User-Defined File
Inclusion.

1. Standard File Inclusion : This type uses angle brackets < > to include header files that
are part of the standard library.

2. User-Defined File Inclusion : This type uses double quotes “ " to include files that you
have created.
Standard File Inclusion
• This type uses angle brackets < > to include header files that are part of the standard
library.

• These are pre-written files provided by the language and contain commonly used
functions or utilities.

#include <stdio.h> // Includes the standard input/output functions like printf, scanf

#include <math.h> // Includes mathematical functions like sqrt, pow

Standard File Inclusion(Conti...)
Why Use Standard Library Files?
• These files contain functions and definitions that are already written and tested.
• You can use these functions in your program without having to write them from scratch.

Example :
• Input/Output Operations: Functions like printf, scanf, fopen, etc., which help with reading from and writing
to the console or files.

• Mathematical Functions: Functions like sqrt, pow, sin, cos, etc., which perform mathematical operations.

• String Manipulation: Functions like strlen, strcpy, strcmp, etc., which work with strings
Standard File Inclusion(Conti...)
Example Code :

#include <stdio.h> // For input/output functions

#include <math.h> // For math functions

int main() {
double num = 9.0;

// Using sqrt function from math.h to calculate square root

double result = sqrt(num);

// Using printf function from stdio.h to print the result

printf("The square root of %.2f is %.2f\n", num, result);

return 0;
}
Standard File Inclusion(Conti...)
Explanation of the Code:
• #include <stdio.h>: This includes the standard input/output functions, specifically the
printf function, which is used to display output to the console.
• #include <math.h>: This includes the standard math functions, specifically the sqrt
function, which calculates the square root of a number.
• In this case, the compiler will look for stdio.h and math.h in its standard library locations
(e.g., /usr/include on Linux or the default include folder in Windows).
User-Defined File Inclusion
• This type uses double quotes “ “ to include files that you have created.

#include "myheader.h" // Includes a file named "myheader.h" written by the user

User-Defined File Inclusion(Conti...)
Why Use User-Defined File Inclusion ?
• These files are typically used to organize code into smaller, more manageable pieces.
• By breaking your program into multiple files, you can improve code readability,
reusability, and maintainability.
Example :
• You might place all the utility functions in one header file (utils.h) and the main program logic in another
file (main.c).

#include "utils.h" // Including user-defined file containing helper functions

Example:
#include <stdio.h> File name : myheader.h
#include "myheader.h" customFunction()
int main() { {
printf("Hello, World!\n"); Printf(“BHARAT”);
customFunction(); // Defined in "myheader.h" }
return 0;
}
Explanation of the Code
Standard File Inclusion:The program includes <stdio.h> for standard functions like printf.

User-Defined File Inclusion:It includes "myheader.h" using double quotes to access a

custom-defined function.

Functionality:customFunction() is defined in myheader.h to print "BHARAT".The main()

function calls customFunction() after printing "Hello, World!".

File Inclusion Advantages and Disadvantages
Advantages Disadvantages

Modularity: Allows splitting the program Compile Time Overhead: Including

into smaller, manageable parts. unnecessary files can increase compilation
time
Reusability: Common code can be written Dependency Issues: Missing or incorrect
once and reused in multiple files. header files can lead to errors.

Improved Readability: Reduces clutter in File Duplication: If the same file is included
the main program by separating multiple times, it can lead to redundancy
declarations unless include guards are used.
Encapsulation: Encapsulates Complexity: Mismanagement of header file
implementation in .c files and exposes only dependencies can make debugging
necessary interfaces via .h. challenging.
 What is Macros ?
• Macros are a feature in C/C++ that allow you to define reusable constants or expressions that are
replaced by the preprocessor before the code is compiled.

• Whenever the name is used in program, it is replaced by the contents of the macro

• They are created using the #define directive. Do not put a semicolon (;) at the end of #define
statements

• Macros are a way to simplify your code, make it more readable, and reduce repetition.
Types of Macros
Macros in C/C++ can be of two types: Object-like Macros and Function-like Macros.

1. Object-like Macros : These macros are used to define constants.

2. Function-like Macros : These macros are used to define expressions that take parameters,
behaving like inline functions.
Object-like Macros
• These macros are used to define constants.
• They act like a replacement for specific values, making the code easier to read and
maintain.

Syntax : #define MACRO_NAME value

#define PI 3.14159 // Defines a constant for π

#define MAX 100 // Defines the maximum value as 100
How They Work
• The preprocessor replaces every occurrence of the macro name with its value.
Example :
#include <stdio.h>
#define PI 3.14159
#define MAX 100 Output :
Value of PI: 3.14
int main() { Maximum value: 100
printf("Value of PI: %.2f\n", PI);
printf("Maximum value: %d\n", MAX);
return 0;
}
Function-like Macros
• These macros are used to define expressions that take parameters, behaving like inline
functions.
• The parameters are replaced with the actual arguments provided during use.

Syntax : #define MACRO_NAME(parameters) expression

#define SQUARE(x) ((x) * (x)) // Macro to calculate the square of a number

#define MIN(a, b) ((a) < (b) ? (a) : (b)) // Defines the maximum value as 100
How They Work
• The preprocessor replaces the macro with the expression, substituting the parameters with
the provided values.
#include <stdio.h>
#define SQUARE(x) ((x) * (x))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
int main() { Output :
int num = 5;
int a = 10, b = 20; Square of 5: 25
printf("Square of %d: %d\n", num, SQUARE(num));
printf("Minimum of %d and %d: %d\n", a, b, MIN(a, b));
Minimum of 10 and 20: 10
return 0;
}
How They Work
• The preprocessor replaces the macro with the expression, substituting the parameters with the
provided values.
How They Work
Macros Advantages and Disadvantages
Advantages Disadvantages

Simplicity: Easy to use for constants and No Debugging Info: Errors involving macros
simple calculations. are hard to trace as they are replaced
before compilation
Efficiency: Expanded inline, avoiding No Type Safety: Macros do not check the
function call overhead. data type, leading to potential unexpected
results.
Maintainability: Changing a macro updates Code Bloat: Large macros can make the
all its occurrences in the program final code size larger.

Reusable: Simplifies repetitive tasks and Operator Precedence Issues: If parentheses

complex expressions. are not used carefully, calculations may
produce incorrect results.
What is Conditional Compilation?
• Conditional compilation in C/C++ allows specific sections of code to be compiled or
excluded based on certain conditions.
• It means the selection of lines of source code to be compiled and those to be ignored.

• How Conditional Compilation Works.

• #if, #elif, #else, #endif: Used to check a condition and include code based
on its evaluation.
• #ifdef and #ifndef: Used to check whether a macro is defined or not.
Common Use Cases
• Debugging:
Include debugging code during development and exclude it in the final
release.
• Feature Enabling/Disabling:
Compile code for specific features based on flags.
• Platform-Specific Code:
Compile different code depending on the operating system or hardware.
Example
Example
Example 2: Using #ifdef and #ifndef
#include <stdio.h>
#define FEATURE_X // Uncomment to enable FEATURE_X
Output (with #define FEATURE_X)
int main() { Feature X is enabled.
#ifdef FEATURE_X Output (without #define
printf("Feature X is enabled.\n"); FEATURE_X):
#else Feature X is disabled.
printf("Feature X is disabled.\n");
#endif
return 0;
}
Example 1: Debugging Using Conditional Compilation
#include <stdio.h>
#define DEBUG 1 // Enable debugging

#if DEBUG
#define LOG(x) printf("DEBUG: %s\n", x) // Macro to log debug messages
#else DEBUG: Debugging is enabled.
#define LOG(x) // Empty macro (does nothing)
#endif

int main() {
LOG("Debugging is enabled."); // Prints only if DEBUG is 1
return 0;
}
Conditional Compilation Advantages and Disadvantages
Advantages Disadvantages

Flexibility: Easily switch between different

configurations (e.g., debug/release mode). Complexity: Excessive use can make the
code hard to read and maintain.

Error-Prone: Conditional logic errors may

Code Portability: Write platform-specific
lead to unexpected behavior.
code for different operating systems.

Feature Customization: Enable or disable

specific features in the codebase.
What is Pragmas ?
• #pragma is a preprocessor directive in C/C++ used to give specific
instructions to the compiler.
• These instructions can influence how the compiler handles certain tasks, such
as optimizations, warning messages, or code organization.
• Since #pragma is compiler-specific, its behavior may vary depending on the
compiler being used.

Syntax: #pragma token-name

Types of Pragma token-names
Common Uses of #pragma
Pragma startup and exit directives are executed before and after main() function. Not all the
compilers support these directives
 Common Uses of #pragma
The #pragma warn directive is used to hide or display the
warning messages which are displayed during compilation

The three character codes to be used are rvl (return value),

par (parameter used or not), and rch (if the code is unreachable).

If any character code is prefixed by "+", it indicates to show

the warning; prefixed by "–" means indication to the compiler
to hide warnings
 Common Uses of #pragma
The GCC compiler removes an identifier completely from the program. If we want to block an identifier, then
we can use the #pragma GCC poison directive
Common Uses of #pragma ?
Disable Warnings : This use of #pragma allows you to disable specific compiler
warnings, which is useful when you want to suppress warnings for legacy code or special
cases. Example
Explanation
#pragma warning(disable: 4996) // Disable warning 4996 (specific to MSVC)
#include <stdio.h> Here, #pragma
int main() { warning(disable: 4996)
char buffer[20]; disables the warning related to
gets(buffer); // Normally triggers a warning for being unsafe the use of gets() in MSVC
printf("Input: %s\n", buffer); (Microsoft Visual C++).
return 0;
}
Common Uses of #pragma ?
Pack Structures : This use of #pragma adjusts the alignment of structure members in
memory, often to save space or meet specific hardware or protocol requirements.
Example
#pragma pack(1) // Align structure members to 1-byte boundaries Explanation
struct MyStruct {
char a; // 1 byte Without #pragma pack(1), the compiler would align
int b; // 4 bytes, but no padding because of `#pragma pack(1)`
int b to a 4-byte boundary, adding padding after
};
char a.
#pragma pack() // Reset to default alignment
With #pragma pack(1), no padding is added, so the
int main() { structure is tightly packed.
printf("Size of MyStruct: %zu\n", sizeof(struct MyStruct));
return 0;
}
 Common Uses of #pragma ?
Region Markers(#pragma region and #pragma endregion) :
• Used in some compilers (e.g., MSVC) to mark specific sections of code for better
organization and navigation.
• These regions can be collapsed or expanded in the code editor, helping developers manage
large files. Example
Explanation
#pragma
void function1()
{ #pragma region and #pragma
// Code for function1
} endregion enclose a code block,
void function2() making it easier to organize and
{
// Code for function2 navigate in supported IDEs.
}
#pragma
 Benefits of Using #pragma
• Control Over Compiler Behavior: Helps in customizing warnings,
optimizations, and other compiler features.
• Memory Optimization: Packing structures can save memory, especially in
embedded systems or network communication.
• Code Organization: Region markers improve code readability and
maintainability in large files.
 Limitations of Using #pragma
• Compiler Dependency: Not portable; behavior varies across compilers.
• Potential for Misuse: Suppressing warnings might hide genuine issues.
• Performance Trade-Offs: Using tighter structure alignment (#pragma pack)
might reduce memory usage but affect performance on some architectures.
Example
#include <stdio.h> Explanation
#pragma pack(1) This code demonstrates the use of
struct MyStruct { #pragma pack(1) to align the
char a; structure MyStruct on 1-byte
int b; boundaries, preventing padding
between members. As a result, the
};
size of MyStruct is reduced, with
int main() {
char a (1 byte) and int b (4 bytes)
struct MyStruct s;
occupying 5 bytes in total. The
printf("Size of packed structure: %zu\n", sizeof(s));
program prints the size of the
return 0; packed structure.
}