The C preprocessor

The C preprocessor is the first step of the code translation process. It performs some editing tasks before the compiler starts . With Standard C has come a number of useful and powerful techniques that make the preprocessor a genuinely useful tool to the C programmer. The preprocessor is a powerful but must be used carefully (pitfalls)

normally you don’t see the preprocessor output , you can see it by using the -E flag:

# gcc -E samp.c

One duty of the preprocessor is to remove comments, and replace it with blank lines. If any header files are included, these will also appear in the preprocessor output. This can result in a lot of text.

Some preprocessor identifiers:

__LINE__ - Number of line being compiled

__FILE__ - Name of file being compiled

__DATE__ - Compilation date "mm dd yyyy"

__TIME__ - Compilation time "hh:mm:ss"

__func__ - Name of the current function

For Example you can use it for debug:

 printf("Error in line %d in file %s\n", __LINE__, __FILE__);

Macros and pitfalls:

If we define the following macro:

#define MAX(a,b) (a>b)?a:b

If we use it with simple parameters it will work fine but if we put some complexity it can cause some pitfalls for example:

k = MAX(i++, j++);

Will expand to:

k = ((i++) > (j++)) ? (i++) : (j++));

The result is that one of the arguments will increment twice

Names conflicts

We can define a function with the same name as a predefined macro but we need to use parentheses :


#define max(a,b) (a>b)?a:b+9; 

int (max)(int a, int b)
return (a > b) ? a : b+99;

int main(void)
    int i = 10, j = 100, k1,k2;
    k1 = (max)(i, j); // function call
    k2 = max(i, j);  // macro call



The preprocessor will only substitute a macro when the macro is followed by an opening parenthesis (intervening whitespace is allowed). Placing parentheses around the macro name effectively removes the name from the opening parenthesis meaning the preprocessor will leave it alone. It is valid to place parentheses around any C statement without effect

The # operator

The # operator converts macro parameters into strings.

PRINTVAL(ex) printf("%s\n", #ex)

PRINTVAL(f + 10);  // printf("%s\n", "f + 10");

The ## operator

The ## operator provides a portable way of merging separate tokens into one single token.It takes the macro parameters to its right and left and pastes them together. It cannot be the first or last item in a macro.

#define DISPLAY(x) printf("file%sname = %s\n", #x, file##x##name)
const char * file1name  =  "autoexec.bat";
const char * file2name  =  "config.sys";
const char * file3name  =  "";
const char * file4name  =  "";


   DISPLAY(i); // Wrong

String Concatenation

Standard C preprocessors concatenate adjacent strings in the input program

printf("hello" "world");


#if can be used to test the value of preprocessor constants. A constant integer expression is evaluated. This may not include sizeof, any casts or any enumerated types.

#if SYMBOL == 4
#if SYMBOL > 4

The block should ends with #endif and you can use #elif for complex tests

#ifdef and #if defined

#ifdef can be used to determine if a preprocessor symbol has been defined.

#ifdef SYMBOL
... .
#endif /* SYMBOL

This may be replaced by the defined operator that is more flexible than #ifdef:

#if defined(SYM_1) && defined(SYM_2)



Passing Types Into a Macro

Since the preprocessor does not understand C, the following is possible:

#define  SWAP(type, var1, var2) \
{ 		     \
	type   _temp_  =  var1; 	  \
	var1 = var2; 	     \
	var2 = _temp_; 	     \

SWAP(int, i, j)
SWAP(long double, ld1, ld2)
SWAP(date, s1, s2)