C program preprocessors are a type of software tool that are used to process source code before it is compiled. They are typically used to add functionality to the source code, such as macros, #define statements, and include files. Preprocessors are typically invoked by the compiler and are used to make the code more readable and easier to maintain. Some common preprocessors include the GNU C preprocessor (GCC), the Microsoft Visual C++ preprocessor, and the Borland C++ preprocessor.
- Writing the code: The first step is to write the code using a text editor or an IDE (Integrated Development Environment). This code is written in C language, which is a high-level programming language.
- Preprocessing: Once the code is written, it is passed through a preprocessor. A preprocessor is a program that processes the code before it is passed to the compiler. It makes changes to the code based on the preprocessor directives that are present in the code.
- Compilation: The preprocessed code is then passed to the compiler, which converts the code into machine-readable form. The compiler generates an object file, which contains machine-readable instructions that can be executed by the computer.
- Linking: After the object file is generated, it is passed to the linker. The linker combines the object file with other object files and libraries to create a final executable file.
- Execution: The final executable file can now be executed on a computer, which will carry out the instructions as specified in the code.
Some common preprocessor directives include #define, #include, and #ifdef. The #define directive is used to define macros, which are short pieces of code that can be reused throughout the program. The #include directive is used to include code from other files, such as header files. The #ifdef directive is used to conditionally include code based on whether a certain macro is defined or not.
Preprocessors are important tools that can make a developer's work more efficient by allowing them to reuse code, include external libraries, and add functionality to their programs. However, they can also make the code more complex and harder to debug if not used properly.
#include is one of the most commonly used preprocessor directives. It is used to include code from other files, such as header files, into the current source code file. This allows developers to reuse code and make their programs more modular and easier to maintain. For example, if you have a header file named "header.h" that contains a function that you want to use in your program, you can include it using the #include directive like this: #include "header.h"
#define is another commonly used preprocessor directive. It is used to define macros, which are short pieces of code that can be reused throughout the program. Macros are often used to define constants and other values that are used multiple times in the program. For example, you can define a macro named PI with the value 3.14 like this: #define PI 3.14
#ifndef is used to check if a certain macro is not defined. If the macro is not defined, the code following the #ifndef directive will be included in the program. This can be used to conditionally include code based on whether a certain macro is defined or not. For example:
#ifdef is used to check if a certain macro is defined. If the macro is defined, the code following the #ifdef directive will be included in the program. This can also be used to conditionally include code based on whether a certain macro is defined or not.
There are 4 Main Types of Preprocessor Directives:
- Macros: Macros are one of the most commonly used preprocessor directives. They are used to define short pieces of code that can be reused throughout the program. Macros are often used to define constants and other values that are used multiple times in the program. They are defined using the #define directive and can be invoked using the macro name.
- File Inclusion: The #include directive is used to include code from other files, such as header files, into the current source code file. This allows developers to reuse code and make their programs more modular and easier to maintain. It also helps to break down the code into smaller manageable pieces.
- Conditional Compilation: Conditional compilation is used to conditionally include or exclude code based on certain conditions. The #ifdef and #ifndef directives are used to check if a certain macro is defined or not, and the code following these directives will be included or excluded based on the result. This can be used to enable or disable certain features in the program based on the environment in which it is run.
- Other Directives: There are several other preprocessor directives that are not as commonly used, but are still important to know. Some examples include #undef, which is used to undefine a macro, #pragma, which is used to include compiler-specific commands, and #error, which is used to generate an error message during compilation.
Macros
For example, to define a macro named PI with the value 3.14, we would use the following code:
It is important to note that there is no semi-colon at the end of the macro definition. Macro definitions do not need a semi-colon to end.
Once a macro is defined, it can be used throughout the program in place of the actual value. For example, in the following program, we use the macro to calculate the area of a circle:
When the program is run, the compiler will replace all instances of the macro name PI with the actual value 3.14. So, the above program will be executed as if we had written it like this:
Macros can also be defined with expressions or other macro names, not just with a simple value. For example:
It is important to note that macros are processed by the preprocessor and not by the compiler, which means that the macro name is replaced with the actual code before the program is compiled. This can make the code more complex and harder to debug if not used properly.
Macros with arguments are similar to functions in that they can take input and perform some operation on that input. They are defined using the #define preprocessor directive, and the arguments are enclosed in parentheses following the macro name.
The syntax for defining a macro with arguments is as follows:
For example, to define a macro that calculates the area of a rectangle, we could use the following code:
This macro can then be used in the program by passing in the values for the length and width of the rectangle.
When the program is run, the macro will be expanded and replaced with the actual code, so the above program will be executed as if we had written it like this:
It's important to note that macros with arguments do not perform type checking, unlike functions. This means that the macro will not check if the arguments passed in are of the correct type. Also, macros with arguments do not have a scope like functions, so any variables defined within the macro will have the same scope as the macro itself.
File Inclusion
The #include preprocessor directive is used to include code from other files, such as header files, into the current source code file. This allows developers to reuse code and make their programs more modular and easier to maintain.
There are two types of files that can be included by the user in the program: header files or standard files and user-defined files.
Header files or standard files: These files contain definitions of pre-defined functions like printf(), scanf(), etc. These files must be included to work with these functions. Different functions are declared in different header files. For example, standard I/O functions are in the ‘iostream’ file whereas functions that perform string operations are in the ‘string’ file. The syntax for including these files is:
where file_name is the name of the file to be included. The ‘<‘ and ‘>’ brackets tell the compiler to look for the file in the standard directory.
User-defined files: When a program becomes very large, it is a good practice to divide it into smaller files and include them whenever needed. These types of files are user-defined files. These files can be included as:
The ‘” ” ‘ (double quotes) tell the compiler to look for the file in the current working directory.
Including files in the program can make it more organized and easier to maintain. It also allows for code reuse, making the development process more efficient. However, it's important to use the correct syntax for including files and to make sure that the files being included are in the correct location. It's also important to be mindful of the number of files being included, as including too many files can slow down the compilation process.
Conditional Compilation
Option 1
For example, if we have a macro named DEBUG defined and we want to include some debug code in the program only when the macro is defined, we can use the following code:
On the other hand, the #ifndef directive checks if a certain macro is not defined, and if it is not, the code following the #ifndef directive will be included in the program. The syntax for using the #ifndef directive is as follows:
For example, if we want to include some code only when the macro DEBUG is not defined, we can use the following code:
In this example, the code inside the #ifndef block will only be executed if the macroDEBUG is not defined.
It is important to note that the #ifdef and #ifndef directives are processed by the preprocessor and not by the compiler, which means that the code following these directives will be included or excluded before the program is compiled. This can be useful for enabling or disabling certain features in the program based on the environment in which it is run.
Option 2
#ifndef: This directive is the opposite of #ifdef. The controlled text will get included in the preprocessor output if the macroname is not defined. Syntax:
#if: This directive allows you to specify a more complex condition, rather than just whether a macro is defined or not. The expression following the #if must evaluate to a non-zero value for the controlled text to be included in the preprocessor output. Syntax:
#elif: This directive is used in conjunction with #if and #ifdef. It allows you to specify additional conditions that will be evaluated if the previous conditions fail. Syntax:
The #ifndef directive is used to check if a macro or identifier is not defined, and if it is not defined, the block of statements between #ifndef and #endif will be executed. This is useful for checking if a specific macro or identifier has not been defined in the program and taking appropriate action if it is not defined.
For example, if we want to check if a macro named "MY_MACRO" has been defined and take different actions based on whether it is defined or not, we can use the following code:
This way, we can use the #ifndef directive to control the flow of the program and ensure that certain sections of code only execute if specific macros or identifiers are not defined.
It's important to note that the #ifndef directive should not be used as an alternative to the #ifdef directive, it should be used when you want to check if a macro or identifier is not defined.
Option 3
The #if, #else and #elif directives are used together to control the compilation of portions of the program based on certain conditions.
The #if directive is used to specify a condition, and if the condition evaluates to a non-zero value, the group of lines immediately following the #if directive will be executed. If the condition evaluates to zero, the compiler will move on to the next directive, which is typically the #elif or #else directive.
The #elif directive is used to specify an additional condition, and if the condition evaluates to a non-zero value, the group of lines immediately following the #elif directive will be executed. If the condition evaluates to zero, the compiler will move on to the next directive, which is typically the next #elif or #else directive.
The #else directive is used to specify a default block of code to be executed if all previous conditions have evaluated to zero. The group of lines immediately following the #else directive will be executed if all previous conditions have evaluated to zero.
The #endif directive is used to indicate the end of the conditional block.
For example, if we want to check if a macro named "MY_MACRO" has been defined and take different actions based on whether it is defined or not, we can use the following code:
This way, we can use the #if, #elif, and #else directives to control the flow of the program and ensure that certain sections of code only execute if specific conditions are met.
Other Directives
For example, if we want to undefine a macro named LIMIT, we would use the following code:
Using this statement will undefine the existing macro LIMIT. After this statement, every “#ifdef LIMIT” statement will evaluate as false.
The #pragma directive is a special purpose directive that is used to turn on or off certain features. This directive is compiler-specific, which means that it can vary from compiler to compiler. The syntax for using the #pragma directive is as follows:
For example, some compilers may use the #pragma directive to turn on or off certain warning messages. A common use of the #pragma directive is to disable specific warnings that the compiler generates.
In this example, the #pragma directive is used to disable the warning for uninitialized variables.
#pragma startup and #pragma exit: These directives help us to specify the functions that are needed to run before program startup (before the control passes to main()) and just before program exit (just before the control returns from main()). For example, if we want to run a function named init() before the program starts and a function named cleanup() before the program exits, we can use the following code:
It's important to note that GCC does not support #pragma startup or exit, so these directives may not work with all compilers.
#pragma warn Directive: This directive is used to hide the warning message which is displayed during compilation. For example, if we want to disable a warning for uninitialized variables, we can use the following code:
This directive will tell the compiler to disable the warning for uninitialized variables. The specific warning codes that can be used with the #pragma warn directive will vary depending on the compiler used.
#pragma warn -rvl: This directive hides those warnings which are raised when a function that is supposed to return a value does not return a value. For example, if we have a function that is supposed to return an int value but doesn't have a return statement, the compiler will raise a warning. To hide this warning, we can use the following code:
#pragma warn -par: This directive hides those warnings which are raised when a function does not use the parameters passed to it. For example, if we have a function that takes in a parameter but doesn't use it, the compiler will raise a warning. To hide this warning, we can use the following code:
#pragma warn -rch: This directive hides those warnings which are raised when a code is unreachable. For example, any code written after the return statement in a function is unreachable. To hide this warning, we can use the following code:
It's important to note that the specific warning codes that can be used with the #pragma warn directive will vary depending on the compiler used. These directives can be useful in hiding unnecessary warnings during the compilation process but it's important to understand the consequences of hiding such warnings as it might lead to logical errors.
Line Control
The #line directive is used to control the line numbers and file names that the compiler provides during errors in compilation.
The #line directive is used to specify a line number and file name that will be used for the next line of code. The line number parameter specifies the line number that will be assigned to the next code line, and the file name parameter specifies the file name that will be used for the next code line. This can be useful for debugging and error handling, as it allows developers to specify the line numbers and file names that the compiler should use when reporting errors.
For example, if we want to specify a line number of 50 and file name of "myfile.c" for the next line of code, we can use the following code:
This way, the compiler will report any errors that occur on the next line of code as being on line 50 of "myfile.c"
It's important to note that the #line directive only affects the line numbers and file names that the compiler reports when there are errors in the program, it does not affect the actual line numbers and file names in the program.
Error Directive
The #error directive is used to abort the compilation process and produce an error when it is found in the program during compilation.
The #error directive is used to specify an error message that will be displayed when the compiler encounters this directive in the program. This can be useful for debugging and error handling, as it allows developers to specify an error message that will be displayed when certain conditions are met.
For example, if we want to produce an error message "invalid macro" when the macro "MY_MACRO" is not defined, we can use the following code:
This way, the compiler will display an error message "invalid macro" if the macro "MY_MACRO" is not defined
It's important to note that the #error directive stops the compilation process and the program will not be compiled or executed if the error directive is found.
