Your code may be compiled on a PC, Mac, Linux system, or even some microcontroller. In each case, it helps to know the environment before you code. You can guess, but it’s better to use the defined constants — if they’re available to you.
What do you do when a constant isn’t available? Actually, what’s more important is being able to check whether or not a constant exists. To manage that feat, you use the preprocessor directives: #ifdef
, #else
, and #endif
.
If you’re just starting out with C coding, you probably haven’t used preprocessor directives beyond #include
and the occasional #define
. The if-else series of directives are easy to understand, providing you have a general concept of the if-else programming thing.
As a real-life example, consider the constant PATH_MAX
. It’s determines how many characters are allowed in a full pathname. The value differs between the various operating systems, so it’s best to use PATH_MAX
to set the buffer size for pathnames, as opposed to just guessing.
To confirm that the PATH_MAX
constant is defined, use the #ifdef
directive:
#ifdef PATH_MAX
When PATH_MAX
is defined, the statements following #ifdef
are compiled.
When PATH_MAX
isn’t defined, the #else
directive takes over. The statements following #else
are compiled when PATH_MAX
is undefined.
The #endif
directive closes the decisions structure. It’s traditionally followed by a comment identifying the constant.
The following code represents a real-life example of testing for the PATH_MAX
constant, which should be defined in the limits.h
header file:
#include <stdio.h>
#include <limits.h>
int main()
{
#ifdef PATH_MAX
printf("PATH_MAX is defined as %d.\n",PATH_MAX);
#else
printf("PATH_MAX isn't defined on this system.\n");
#endif /* PATH_MAX */
return(0);
}
When the PATH_MAX
variable is defined, the first printf() statement is compiled, otherwise the second one is compiled. Remember, preprocessor directives don’t execute when the program runs; they simply tell the compiler which part of the code to include in the final program.
Here’s the output for my Macintosh:
PATH_MAX is defined as 1024.
Here’s the output on my PC:
PATH_MAX is defined as 260.
The differing values justify why using a constant like PATH_MAX
is important. The alternative would be to guess and specify a “safe” value for the constant. That’s a valid option only when you’ve tried testing for a constant as shown in this Lesson’s sample code.