Seminar 1

RP SARATHY INSTITUTE OF TECHNOLOGY-SALEM
SEMINAR
CS3353-C PROGRAMMING AND DATA STRUCTURES
C Pre-processors
Preprocessors are programs that process the source code before
compilation. Several steps are involved between writing a program and
executing a program in C.
Let us have a look at these steps before we actually start learning about
Preprocessors.
You can see the intermediate steps in the above diagram. The source
code written by programmers is first stored in a file, let the name be
“program.c“.
This file is then processed by preprocessors and an expanded source
code file is generated named“program.i”.
This expanded file is compiled by the compiler and an object code file is
generated named “program.obj”.
Finally, the linker links this object code file to the object code of the
library functions to generate the executable file “program.exe”.
Preprocessor Directives in C
Preprocessor programs provide preprocessor directives that tell the
compiler to preprocess the source code before compiling.
All of these preprocessor directives begin with a ‘#’ (hash) symbol. The
‘#’ symbol indicates that whatever statement starts with a ‘#’ will go to the
preprocessor program to get executed.
We can place these preprocessor directives anywhere in our program.
To better understand how preprocessors can enhance the efficiency of your
programs, especially when working with data structures,
Examples of some preprocessor directives are
#include, #define, #ifndef, etc.
Note Remember that the # symbol only provides a path to the preprocessor,
and a command such as include is processed by the preprocessor program.
For example, #include will include the code or content of the specified file in
your program.
List of preprocessor directives in C

The following table lists all the preprocessor directives in C:
Preprocessor Directives Description
#define Used to define a macro
#undef Used to undefine a macro
Used to include a file in the source

#include
code program
Used to include a section of code if a

#ifdef
certain macro is defined by #define
Used to include a section of code if a

#ifndef
certain macro is not defined by #define
#if Check for the specified condition
Alternate code that executes when #if

#else
fails
Combines else and if for another

#elif
condition check
Used to mark the end of #if, #ifdef, and

#endif
#ifndef
Types of C Preprocessors
There are 4 Main Types of Preprocessor Directives:
1. Macros
2. File Inclusion
3. Conditional Compilation
4. Other directives
1. Macros
In C, Macros are pieces of code in a program that is given some name.
Whenever this name is encountered by the compiler, the compiler replaces the
name with the actual piece of code. The ‘#define’ directive is used to define a
macro.
Syntax of Macro Definition
#define token value
where after preprocessing, the token will be expanded to its value in the
program.
// C Program to illustrate the macro
#include <stdio.h>
// macro definition
#define LIMIT 5
int main()
for (int i = 0; i < LIMIT; i++) {
printf("%d \n", i);
return 0;
}
Macros With Arguments

We can also pass arguments to macros. Macros defined with arguments work
similarly to functions.
Example
#define foo(a, b) a + b
#define func(r) r * r
2. File Inclusion
This type of preprocessor directive tells the compiler to include a file in
the source code program. The #include preprocessor directive is used to
include the header files in the C program.
There are two types of files that can be included by the user in the
program:
Standard Header Files
The standard header 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.
Syntax
#include <file_name>
where file_name is the name of the header file to be included. The ‘<‘ and ‘>’
brackets tell the compiler to look for the file in the standard directory.
User-defined Header 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 header files.
Syntax
#include "filename"
The double quotes ( ” ” ) tell the compiler to search for the header file in
the source file’s directory.
3. Conditional Compilation
Conditional Compilation in C directives is a type of directive that helps to
compile a specific portion of the program or to skip the compilation of some
specific part of the program based on some conditions. There are the following
preprocessor directives that are used to insert conditional code:
1. #if Directive
2. #ifdef Directive
3. #ifndef Directive
4. #else Directive
5. #elif Directive
6. #endif Directive
#endif directive is used to close off the #if, #ifdef, and #ifndef opening
directives which means the preprocessing of these directives is completed.
Syntax
#ifdef macro_name
// Code to be executed if macro_name is defined
#ifndef macro_name
// Code to be executed if macro_name is not defined
#if constant_expr
// Code to be executed if constant_expression is true
#elif another_constant_expr
// Code to be excuted if another_constant_expression is true
#else
// Code to be excuted if none of the above conditions are true
#endif
4. Other Directives
Apart from the above directives, there are two more directives that are not
commonly used. These are:
1. #undef Directive
2. #pragma Directive
1. #undef Directive
The #undef directive is used to undefine an existing macro. This directive
works as:
#undef LIMIT
Using this statement will undefine the existing macro LIMIT. After this
statement, every “#ifdef LIMIT” statement will evaluate as false.
2. #pragma Directive
This directive is a special purpose directive and is used to turn on or off some
features. These types of directives are compiler-specific, i.e., they vary from
compiler to compiler.
Syntax
#pragma directive
Some of the #pragma directives are discussed below:
1. #pragma startup: These directives help us to specify the functions that are
needed to run before program startup (before the control passes to main()).
2. #pragma exit: These directives help us to specify the functions that are
needed to run just before the program exit (just before the control returns
from main()).
#pragma warn Directive

This directive is used to hide the warning message which is displayed
during compilation. We can hide the warnings as shown below:
 #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.
 #pragma warn -par: This directive hides those warnings which are raised
when a function does not use the parameters passed to it.
 #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.

Seminar 1

Uploaded by

Copyright:

Available Formats

Seminar 1

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Seminar 1

Uploaded by

Copyright:

Available Formats

RP SARATHY INSTITUTE OF TECHNOLOGY-SALEM

List of preprocessor directives in C

#define Used to define a macro

#undef Used to undefine a macro

Used to include a file in the source

Used to include a section of code if a

Used to include a section of code if a

#if Check for the specified condition

Alternate code that executes when #if

Combines else and if for another

Used to mark the end of #if, #ifdef, and

// C Program to illustrate the macro

for (int i = 0; i < LIMIT; i++) {

printf("%d \n", i);

Macros With Arguments

User-defined Header Files

#pragma warn Directive

You might also like