The C Preprocessor is not part of the compiler, but is a separate step in the compilation process. In simplistic terms, a C Preprocessor is just a text substitution tool and they instruct compiler to do required pre-processing before actual compilation. We'll refer to the C Preprocessor as the CPP.

    All preprocessor commands begin with a pound symbol (#). It must be the first nonblank character, and for readability, a preprocessor directive should begin in first column. Following section lists down all important preprocessor directives:

Analyze following examples to understand various directives.

				#define MAX_ARRAY_LENGTH 20

This directive tells the CPP to replace instances of MAX_ARRAY_LENGTH with 20. Use #define for constants to increase readability.

				#ifndef MESSAGE
				#define MESSAGE "You wish!"
				#endif

This tells the CPP to define MESSAGE only if MESSAGE isn't already defined.

				#ifdef DEBUG 
				/* Your debugging statements here */ 
				#endif/pre>
			
This tells the CPP to do the process the statements enclosed if DEBUG is defined. This is useful if you pass the -DDEBUG flag to gcc compiler at the time of compilation. This will define DEBUG, so you can turn debugging on and off on the fly during compilation.
		

Preprocessor Operators

The C preprocessor offers following operators to help you in creating macros:

Macro Continuation (\)

A macro usually must be contained on a single line. The macro continuation operator is used to continue a macro that is too long for a single line. For example:

					#define message_for(a, b) \
					printf(#a " and " #b ": We love you!\n")

Stringize (#)

The stringize or number-sign operator ('#'), when used within a macro definition, converts a macro parameter into a string constant. This operator may be used only in a macro that has a specified argument or parameter list. For example:

					#include <stdio.h>
					#define message_for(a, b) \
					printf(#a " and " #b ": We love you!\n")
					int main( void )
					{
					message_for(Carole, Debra);
					return 0;
					}

Token Pasting (##)

The token-pasting operator (##) within a macro definition combines two arguments. It permits two separate tokens in the macro definition to be joined into a single token. For example:

					#include <stdio.h>
					#define tokenpaster(n) printf ("token" #n " = %d", token##n)
					int main( void )
					{
					int token34 = 40;
					tokenpaster(34);
					return 0;
					}

The defined() Operator

The preprocessor defined operator is used in constant expressions to determine if an identifier is defined using #define. If the specified identifier is defined, the value is true (non-zero). If the symbol is not defined, the value is false (zero). The defined operator is specified as follows:

					#include <stdio.h>
					#if !defined (MESSAGE)
					#define MESSAGE "You wish!"
					#endif
					int main( void )
					{
					printf("Here is the message: %s\n", MESSAGE);
					return 0;
					}