The Pre-Processor and standard libraries - Function Like Macros

An extension of the #define directive allows parameters to be associated with preprocessor directives in a notation very reminiscent of a function. These are normally called macros or function-like macros . getchar(), putchar() and the isathing() macros are examples that are defined in the header files stdio.h and ctype.h respectively.

The basic syntax is

A simple example might be

this means that code such as

is converted into

by the preprocessor. This is very handy, however there are some problems. Consider the example

This is quite satisfactory for usages such as

which is converted to

but the conversion of

to

is unlikely to have the effect that the programmer intended. To avoid this problem it is essential to write

Once this has been done the preprocessor will convert

to

Of course there are still some problems with usages such as

being converted to

which always has the value 1. To solve this problem a macro such as square is always defined as

the immediate previous example converting to

Unfortunately there are some problems that cannot be resolved. Consider the following program.

#define	square(x)	((x)*(x))
main()
{
	int	i=0;
	while(i<16)
		printf("%2d %4d\n",i,square(i++));
}

 2    0
 4    6
 6   20
 8   42
10   72
12  110
14  156
16  210

which, of course, increments "i" twice not once. Note also the right to left order of function parameter evaluation. This sort of problem causes most C programmers to use function-like macros with considerable care.

Of course macro definitions within comments are not seen by either the compiler or the pre-processor; comments are stripped from the source program before pre-processing. Macros and #define' d identifiers are not seen when they are referenced inside strings however the value associated with a pre-processor definition may be a string.

Also if the formal parameter associated with a macro is preceded by a "#" symbol in the replacement string then a string complete with enclosing quotes and all relevant escapes is formed. This operation is known as stringizing. It is illustrated by the following program.

#define	string(x)	#x
main()
{
	printf(">>%s<<\n",string(a string));
	printf(">>%s<<\n",string(" quoted "));
}

>>a string<<
>>" quoted "<<

#define	showx(x)	printf( #x " = %d  ",(x))
#define	show1(x)	showx(x);printf("\n")
#define	show2(x,y)	showx(x);show1(y)
#define	show3(x,y,z)	showx(x);show2(y,z)
#define	show4(x,y,z,p)	showx(x);show3(y,z,p)

main()
{
	int	a = 4;
	int	b = 9;
	int	c = 7;
	int	d;
	show1(c+d);
	show3(a,b+c,d=a+b);
	show4(a*b,b*c,c*d,d*a);
}

c+d = 7  
a = 4  b+c = 16  d=a+b = 13  
a*b = 36  b*c = 63  c*d = 91  d*a = 52  

	"showx(c+d);printf("\n");

	printf("c+d" " = %d  ",(c+d))

If it is not possible or convenient to write the complete text of a function-like macro on one line then it can be written over several lines if there is an escaping backslash immediately before the end of each line.

The pre-processor also provides facilities to paste together tokens to form a single token after pre-processing. This is called token pasting and is achieved using the ## symbol. This simply means join up the two items on either side of the ## as if they were a single text token. Token pasting is illustrated by the following program

#include	<stdio.h>
#define	shown(x)	printf("%d",n##x)
main()
{
	int	n1 = 3;
	int	n2 = 4;
	int	n3 = 5;
	shown(1);
	shown(2);
	shown(3);
	putchar('\n'); 
}

345

	printf("%d",n1)

	printf("%d",n 1)

There are further complex rules defining the behaviour of the preprocessor when handling replacement strings which include identifiers that were #define' d in an earlier pre-processor directive.