C language – Preprocessors and Header files in C

In C language the C preprocessor is often known as a macro processor that is used automatically by the C compiler to transform your program before compilation.

It is called a macro processor because it allows you to define macros, which are brief abbreviations for longer constructs. The C preprocessor is intended to be used only with C, C++, and Objective C source code.

Initial Processing

In C language the preprocessor performs a series of textual transformations on its input. These happen before all other processing.

Conceptually, they happen in a rigid order, and the entire file is run through each transformation before the next one begins.

C actually does them all at once, for performance reasons. these transformations correspond roughly to the first three “phases of translation”.

The Preprocessor in C language

The preprocessor contains any operations in the preprocessing language, it will be transformed first.

This stage corresponds roughly to the standard’s translation phase and is what most people think of as the preprocessor’s job.

The preprocessing language consists of directives to be executed and macros to be expanded. Its primary capabilities are:

• Inclusion of header files: These are files of declarations that can be substituted into your program.
• Macro expansion: You can define macros, which are abbreviations for arbitrary fragments of C code. The preprocessor will replace the macros with their definitions throughout the program. Some macros are automatically defined for you.
• Conditional compilation: You can include or exclude parts of the program according to various conditions.
• Line control: If you use a program to combine or rearrange source files into an intermediate file which is then compiled, you can use line control to inform the compiler where each source line originally came from.
• Diagnostics: You can detect problems at compile time and issue errors or warnings.

Header files in C language

A header file is a file containing C declarations and macro definitions to be shared between several source files.

You request the use of a header file in your program by including it, with the C preprocessing directive ‘#include‘.

File inclusion

This is used to include an external file, which contains functions or some other macro definitions to our source program, so do not rewrite the functions and macros in our source program.

Syntax:
       #include"file name"
       #include 
Example
      #include 
      #include"loop.c"

here “stdio.h” is the file containing standard input and output function in ‘C‘ standard directory, “loop.c” is the program written by the user, it frequently occurs in many source programs.

Computed Includes

Sometimes it is necessary to select one of several different header files to be included in your program.

They might specify configuration parameters to be used on different sorts of operating systems, for instance. You could do this with a series of conditionals,

    #if SYSTEM_1
    # include "system_1.h"
    #elif SYSTEM_2
    #  include  "system_2.h"
    #elif  SYSTEM_3
       .....
    #endif

That rapidly becomes tedious, the preprocessor offers the ability to use a macro for the header name. This is called a computed include.

Instead of writing a header name as the direct argument of ‘#include’, you simply put a macro name there instead

#define SYSTEM_H "system_1.h"
        ....
#include SYSTEM_H

SYSTEM_H will be expanded, and the preprocessor will look for ‘system_1.h’ as if the ‘#include‘ had been written that way originally.

Macros in C language

In the C programming language, a macro is a fragment of code that has been given a name. Whenever the name is used, it is replaced by the contents of the macro. There are two kinds of macros.

They differ mostly in what they look like when are used. Object-like macros resemble data objects when used, function like macros resemble function calls.

You may define any valid identifier as a macro, even if it is a C keyword. The preprocessor does not know anything about keywords.

Macro substitution

This is used to define symbolic constants in the source program. The identifier or string or integer defined is replaced by Macro substitution.

Syntax:
#define identifier string/integer

The preprocessor accomplishes the task specified in the ‘# define‘ statement. This statement is also placed before the main() function in the source program.

1) Simple macros in c language

This is commonly used to define symbolic constants

Example:
#define  age 20
#define  CITY "CHENNAI"
#define  g   9.8
#define  A   10

The #define A 10 macro substitutes ‘A’ with 10 in all occurrences in the source program. The Expression can also be defined in macros as follows.

Example:
  #define A 10-5
  #define B 20-10

Consider an arithmetic operation in source program : c=(A) + (B). The results of the above expressions gives: c = (10-5) + (20-10). The literal text can also be substituted using macros.

Example:
#define exp if(10>5)
 #define True printf("Greater");
 #define false else printf("lesser");

To build the above macro as a statement like exp True False gives

if(10>5)
     printf("Greater");
else
     printf("Lesser");

2) Argumented macros

The argument macros are used to define more complex and useful forms of replacements in the source program.

Syntax:
#define identifier (v1 v2 v5...v4) string/integer

Example program

Program to print square and cube values by using macros substitutions.