Preprocessor Directives in C – LinuxWays

The #include directive includes the headers in the compilation where the functions that we use, their variables, structures, directives, etc. are declared. When the precompiler encounters this directive, it replaces it with the code that is contained in the specified file. Let’s see the #include syntax:

If the name of the header is between the < > symbols, the precompiler looks for the files in the “includes” of the libraries. While if it is between the quotation marks, it looks in the directory where the main file of “c” that is to be compiled is located. The #include directives must be in the first lines of the code.

In this example, we will see how to use the #include directive to include the “stdio.h” header which defines the printf() function that we will use to print the “hello World” message in the command console. Let’s see the code for this example:

The #define directive is very useful in C and we can find it in the various headers that define the functions. The usefulness of this directive is wide and it is used to:

1. Define the constants and flags
2. Define the macro functions
3. Include the code snippets to the compilation using the “this” and “conditionals” directives

Let’s see the syntax that is used by this directive to declare a constant and assign it with a value:

To define a macro function with this directive, we have to use the following syntax:

The #undef directive has the opposite effect of the #define and is used to remove the definitions that have already been created. Let’s see the syntax of this declaration to undefine a constant:

In this example, we define a constant with the CONST_1 identifier and assign it with the value of 15. Then, we print its value with the printf() function using the constant as an input argument.

Let’s see an example where we define the conv() macro function with the #define directive which converts its input argument from inches to centimeters:

These conditionals include or exclude the code fragments from the compilation based on a previous definition or the result of a relational operation.

These directives allow us to include only the headers, libraries, and fragments that are necessary for a particular compilation which significantly reduces the final size of the program by not including the unnecessary code. Also, the code becomes portable and we can specify the different compilation modes which we can easily define with the #define directive.

In the following, you will find a list of conditional preprocessor directives available in C:

Whenever we open one or a series of conditional directives, we must mark their end with #endif.

The #ifdef and #ifndef directives are conditional directives that depend on a previous definition. Let’s see how the #ifdef directive works:

The #ifndef directive works in the opposite way. It includes the assigned code if the constant of its condition is not defined which, in this case, is US.

In this example, we will see how we can use the #ifdef and #ifndef conditional directives to make our code portable while creating a lightweight and readable program. To do this, we create a simple application that calculates the circumference of a circle based on a radius that we enter through the console. The interesting thing is that it supports two languages, English (US) and Spanish for Latin America (LATAM) and uses the unit of measurement corresponding to the zone chosen. Let’s see the C code for this program:

These conditional directives include the code fragments in the compilation depending on whether the result of a relational operation between values of predefined constants is true or false. Then, we will see how these directives are applied:

The preprocessor includes the code that is contained in the conditional statement whose result of the relational operation with the ZONE constant equals to true which, in this case, is the #elif statement with the FR constant.

Now, let’s look at an example where we use these three directives that take the code from the previous example and make some changes to the “myheader.h” file to add the French language to the program.

First, we define the FR, LATAM, and US constants and assign a value to each. Also, in the C code, before inserting the “myheader.h” header, we define the ZONE constant which we will use to select the language of the program by assigning the value of one of the three constants that we just defined. The ZONE constant will be the condition for the conditional directives.

Next, we add the #if, #elif, and #else directives in the header. The code for the FR language is inserted under the #if directive, the LATAM code under #elif, and the US code under the #else directive. This way, we have three compilation versions. But if you want to add more, you can insert as many #elif statements as you want, as long as each has a different constant value in the relational operation.

The #else directive does not perform any relational operations, so US is the default language and can be entered with any value except FR or LATAM. Let’s see the code for the “myheader.h” header:

To choose in which language we want to compile our program, we just need to define the ZONE constant in the code and assign it with one of the three values (US, FR or LATAM) that are defined in the header. Let’s see the code with the language options that are commented out so that the default zone, which is US, is compiled:

These directives are used to send error or warning messages to the compiler output. These directives are usually used in headers within error detection conditionals. The message to be displayed in the compiler output must be in the text form and not a string. Let’s see an example of the use of these two directives:

In the following figure, we will see the compilation of this code with the error and warning messages it contains:

In this Linux Ways article, we explained to you what the preprocessor directives are all about and what their function is when compiling the code. In this article, we looked at each of these directives and showed you their syntax and usage. To help you quickly implement the use of preprocessor directives, we included a practical example for each of them, with code fragments and images, so that you can see the potential of these directives for code portability and optimization of the final program.