Yes. This can be done by using the #if, #else, and #endif preprocessor directives. For example, certain compilers use different names for header files. One such case is between Borland C++, which uses the header file alloc.h, and Microsoft C++, which uses the header file malloc.h. Both of these headers serve the same purpose, and each contains roughly the same definitions. If, however, you are writing a program that is to support Borland C++ and Microsoft C++, you must define which header to include at compile time. The following example shows how this can be done:

#ifdef __BORLANDC__
#include <alloc.h>
#else
#include <malloc.h>
#endif

When you compile your program with Borland C++, the __BORLANDC__ symbolic name is automatically defined by the compiler. You can use this predefined symbolic name to determine whether your program is being compiled with Borland C++. If it is, you must include the alloc.h file rather than the malloc.h file.

Yes. Include files can be nested any number of times. As long as you use precautionary measures, you can avoid including the same file twice. In the past, nesting header files was seen as bad programming practice, because it complicates the dependency tracking function of the MAKE program and thus slows down compilation. Many of today's popular compilers make up for this difficulty by implementing a concept called precompiled headers, in which all headers and associated dependencies are stored in a precompiled state.

Many programmers like to create a custom header file that has #include statements for every header needed for each module. This is perfectly acceptable and can help avoid potential problems relating to #include files, such as accidentally omitting an #include file in a module.

Even though there is no limit to the number of levels of nested include files you can have, your compiler might run out of stack space while trying to include an inordinately high number of files. This number varies according to your hardware configuration and possibly your compiler.

In practice, although nesting include files is perfectly legal, you should avoid getting nest-crazy and purposely implementing a large number of include levels. You should create an include level only where it makes sense, such as creating one include file that has an #include statement for each header required by the module you are working with.

The concatenation operator (##) is used to concatenate (combine) two separate strings into one single string. The concatenation operator is often used in C macros, as the following program demonstrates:

#include <stdio.h>
#define SORT(x) sort_function ## x
void main(void);
void main(void)
{
     char* array;
     int   elements, element_size;
     ...
     SORT(3)(array, elements, element_size);
     ...
}

In the preceding example, the SORT macro uses the concatenation operator to combine the strings sort_function and whatever is passed in the parameter x. This means that the line

SORT(3)(array, elements, element_size);

is run through the preprocessor and is translated into the following line:

sort_function3(array, elements, element_size);

As you can see, the concatenation operator can come in handy when you do not know what function to call until runtime. Using the concatenation operator, you can dynamically construct the name of the function you want to call, as was done with the SORT macro.

A type-insensitive macro is a macro that performs the same basic operation on different data types. This task can be accomplished by using the concatenation operator to create a call to a type-sensitive function based on the parameter passed to the macro. The following program provides an example:

#include <stdio.h>
#define SORT(data_type) sort_ ## data_type
void sort_int(int** i);
void sort_long(long** l);
void sort_float(float** f);
void sort_string(char** s);
void main(void);
void main(void)
{
     int** ip;
     long** lp;
     float** fp;
     char** cp;
     ...
     sort(int)(ip);
     sort(long)(lp);
     sort(float)(fp);
     sort(char)(cp);
     ...
}

This program contains four functions to sort four different data types: int, long, float, and string (notice that only the function prototypes are included for brevity). A macro named SORT was created to take the data type passed to the macro and combine it with the sort_ string to form a valid function call that is appropriate for the data type being sorted. Thus, the string

sort(int)(ip);

translates into

sort_int(ip);

after being run through the preprocessor.

The ANSI C standard defines six predefined macros for use in the C language:

The ANSI C standard includes a predefined macro named __LINE__ that can be used to insert the current source code line number in your program. This can be a very valuable macro when it comes to debugging your program and checking for logic errors. For instance, consider the following portion of code:

int print_document(char* doc_name, int destination)
{
     switch (destination)
     {
          case TO_FILE:
               print_to_file(doc_name);
               break;
          case TO_SCREEN:
               print_preview(doc_name);
               break;
          case TO_PRINTER:
               print_to_printer(doc_name);
               break;
          default:
               printf("Logic error on line number %d!\n", __LINE__);
               exit(1);
     }
}

If the function named print_document() is passed an erroneous argument for the destination parameter (something other than TO_FILE, TO_SCREEN, and TO_PRINTER), the default case in the switch statement traps this logic error and prints the line number in which it occurred. This capability can be a tremendous help when you are trying to debug your program and track down what could be a very bad logic error.

The ANSI C standard includes a predefined macro named __FILE__ that can be used to insert the current source code filename in your program. This macro, like the __LINE__ macro, can be very valuable when it comes to debugging your program and checking for logic errors. For instance, the following code, includes the filename as well as the line number when logic errors are trapped:

int print_document(char* doc_name, int destination)
{
     switch (destination)
     {
          case TO_FILE:
               print_to_file(doc_name);
               break;
          case TO_SCREEN:
               print_preview(doc_name);
               break;
          case TO_PRINTER:
               print_to_printer(doc_name);
               break;
          default:
               printf("Logic error on line number %d in the file %s!\n",
                         __LINE__, __FILE__);
               exit(1);
     }
}

Now, any erroneous values for the destination parameter can be trapped, and the offending source file and line number can be printed.

The ANSI standard for the C language defines a symbol named __cplusplus that is defined only when you are compiling a C++ program. If you are compiling a C program, the __cplusplus symbol is undefined. Therefore, you can check to see whether the C++ compiler has been invoked with the following method:

#ifdef __cplusplus                      /* Is __cplusplus defined? */
#define USING_C FALSE                   /* Yes, we are not using C */
#else
#define USING_C TRUE                    /* No, we are using C */
#endif

When the preprocessor is invoked, it sets USING_C to FALSE if the __cplusplus symbol is defined. Otherwise, if __cplusplus is undefined, it sets USING_C to TRUE. Later in your program, you can check the value of the USING_C constant to determine whether the C++ compiler is being used.

The #pragma preprocessor directive allows each compiler to implement compiler-specific features that can be turned on and off with the #pragma statement. For instance, your compiler might support a feature called loop optimization. This feature can be invoked as a command-line option or as a #pragma directive. To implement this option using the #pragma directive, you would put the following line into your code:

#pragma loop_opt(on)

Conversely, you can turn off loop optimization by inserting the following line into your code:

#pragma loop_opt(off)

Sometimes you might have a certain function that causes your compiler to produce a warning such as Parameter xxx is never used in function yyy or some other warning that you are well aware of but choose to ignore. You can temporarily disable this warning message on some compilers by using a #pragma directive to turn off the warning message before the function and use another #pragma directive to turn it back on after the function. For instance, consider the following example, in which the function named insert_record() generates a warning message that has the unique ID of 100. You can temporarily disable this warning as shown here:

#pragma warn -100    /* Turn off the warning message for warning #100 */
int insert_record(REC* r)   /* Body of the function insert_record() */
{
    /* insert_rec() function statements go here... */
}
#pragma warn +100 /* Turn the warning message for warning #100 back on */

Check your compiler's documentation for a list of #pragma directives. As stated earlier, each compiler's implementation of this feature is different, and what works on one compiler almost certainly won't work on another. Nevertheless, the #pragma directives can come in very handy when you're turning on and off some of your compiler's favorite (or most annoying) features.