{"id":23269,"date":"2023-12-17T12:12:46","date_gmt":"2023-12-17T12:12:46","guid":{"rendered":"https:\/\/linuxways.net\/?p=23269"},"modified":"2024-03-25T02:10:27","modified_gmt":"2024-03-25T02:10:27","slug":"preprocessor-directives-c","status":"publish","type":"post","link":"https:\/\/linuxways.net\/de\/scripting\/preprocessor-directives-c\/","title":{"rendered":"Preprocessor Directives in C"},"content":{"rendered":"

The preprocessor of a compiler acts in the first instance of compilation. In this instance, for example, the compiler inserts the additional code of the functions that is defined in the headers that we insert and call in the code, the defined constants that they will use, and so on.<\/p>\n

The preprocessor configures the compilation based on the requirements of the code that we want to compile using certain directives. Although we generally make little use of the preprocessor directives in simple programs, many of them configure the compilation through the headers that we insert. These directives are a very useful resource to ensure the portability and reduce the size of the final program code by eliminating unnecessary fragments during compilation.<\/p>\n

In this Linux Ways article, you’ll learn what preprocessor directives in C are all about and how to use them. We’ll look at each of the directives available in C, explain their usefulness in detail, and include a practical example with code and pictures where you can learn how they work and quickly put them into practice.<\/p>\n

<\/a>#Include Directive in the C Language<\/h2>\n

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\u2019s see the #include syntax:<\/p>\n

#define <file.extension><\/span>
\n
\n#define "file.extension"<\/span><\/div><\/div>\n

If the name of the header is between the < > <\/em><\/strong>symbols, the precompiler looks for the files in the \u201cincludes\u201d of the libraries. While if it is between the quotation marks, it looks in the directory where the main file of \u201cc\u201d that is to be compiled is located. The #include directives must be in the first lines of the code.<\/p>\n

<\/a>How to Use the #Include Directive to Include the Headers in the C Language<\/h2>\n

In this example, we will see how to use the #include directive to include the \u201cstdio.h\u201d header which defines the printf() function that we will use to print the \u201chello World\u201d<\/em> message in the command console. Let\u2019s see the code for this example:<\/p>\n

#include <stdio.h><\/span>
\n
\nvoid<\/span> main (<\/span>)<\/span>
\n
\n{<\/span>
\n
\nprintf<\/span><\/a> (<\/span>"Hello World\\n<\/span>"<\/span>)<\/span>;<\/span>
\n
\n}<\/span><\/div><\/div>\n

The following image shows the compilation and execution of this code:<\/p>\n

<\/p>\n

 <\/p>\n

<\/a>Had we not used this directive to include the \u201cstdio.h\u201d header, the compiler would not have found the declaration of the printf() function which leads to the following error, one of the classic errors when compiling with GCC if we fail to include a header:<\/p>\n

<\/p>\n

<\/a>#Define and #Undef Directives in the C Language<\/h2>\n

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:<\/p>\n

    \n
  1. Define the constants and flags<\/li>\n
  2. Define the macro functions<\/li>\n
  3. Include the code snippets to the compilation using the \u201cthis\u201d and \u201cconditionals\u201d directives<\/li>\n<\/ol>\n

    Let\u2019s see the syntax that is used by this directive to declare a constant and assign it with a value:<\/p>\n

    #define <CONSTANT> <VALUE><\/span><\/div><\/div>\n

    To define a macro function with this directive, we have to use the following syntax:<\/p>\n

    #define <function prototype> <expression><\/span><\/div><\/div>\n

    The #undef directive has the opposite effect of the #define and is used to remove the definitions that have already been created. Let\u2019s see the syntax of this declaration to undefine a constant:<\/p>\n

    #undef <CONSTANT><\/span><\/div><\/div>\n

    <\/a>
    \nHow to Define a Constant with the #Define Directive in the C Language<\/h2>\n

    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.<\/p>\n

    #include <stdio.h><\/span>
    \n
    \n#define CONST_1 15<\/span>
    \n
    \nvoid<\/span> main (<\/span>)<\/span>
    \n
    \n{<\/span>
    \n
    \n    printf<\/span><\/a> (<\/span>"%i"<\/span>,<\/span> CONST_1)<\/span>;<\/span>
    \n
    \n}<\/span><\/div><\/div>\n

    Let\u2019s see the following image with the compilation and execution of this code that shows the value that is defined to the CONST_1 constant by the #define directive:<\/p>\n

    <\/p>\n

    Let’s see what happens when we remove the definition of the CONST_1 constant with the #undef directive:<\/p>\n

    #include <stdio.h><\/span>
    \n
    \n#define CONST_1 15<\/span>
    \n
    \n#undef CONST_1<\/span>
    \n
    \nvoid<\/span> main (<\/span>)<\/span>
    \n
    \n{<\/span>
    \n
    \n    printf<\/span><\/a> (<\/span>"%i"<\/span>,<\/span> CONST_1)<\/span>;<\/span>
    \n
    \n}<\/span><\/div><\/div>\n

    As the following figure shows, the CONST_1 constant was removed by the #undef directive, so the compiler could not find it and issued an error.<\/p>\n

    <\/p>\n

    <\/a>How to Define a Macro Function with the #Define Directive in the C Language<\/h2>\n

    Let\u2019s see an example where we define the conv() macro function with the #define directive which converts its input argument from inches to centimeters:<\/p>\n

    #include <stdio.h><\/span>
    \n
    \n#define conv(b) a * 2.54<\/span>
    \n
    \nvoid<\/span> main (<\/span>)<\/span>
    \n
    \n{<\/span>
    \n
    \nfloat<\/span> a =<\/span>2.5<\/span>;<\/span>
    \n
    \n    printf<\/span><\/a> (<\/span>"%f inches equal to %f centimeters\\n<\/span>"<\/span>,<\/span> a,<\/span> conv(<\/span>a)<\/span>)<\/span>;<\/span>
    \n
    \n}<\/span><\/div><\/div>\n

    Let\u2019s see the following image with the compilation and execution of this code:<\/p>\n

    <\/p>\n

    <\/a>Conditional Preprocessor Directives<\/h2>\n

    These conditionals include or exclude the code fragments from the compilation based on a previous definition or the result of a relational operation.<\/p>\n

    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.<\/p>\n

    In the following, you will find a list of conditional preprocessor directives available in C:<\/p>\n\n\n\n\n\n\n\n\n\n
    Directive <\/strong><\/td>\nEntry condition<\/strong><\/td>\n<\/tr>\n
    #ifdef <condition><\/strong><\/td>\nIf the condition was previously defined<\/td>\n<\/tr>\n
    #ifndef <condition><\/strong><\/td>\nIf the condition was not previously defined<\/td>\n<\/tr>\n
    #if <condition><\/strong><\/td>\nIf the condition is true<\/td>\n<\/tr>\n
    #elif <condition><\/strong><\/td>\nIf the condition is true and false for #if<\/td>\n<\/tr>\n
    #else<\/strong><\/td>\nIf the condition result false for #if and #elif<\/td>\n<\/tr>\n
    #endif (Delimiter)<\/strong><\/td>\nEnd of conditional<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

     <\/p>\n

    Whenever we open one or a series of conditional directives, we must mark their end with #endif.<\/p>\n

    <\/a>The #Ifdef and #Ifndef Conditional Directives in the C Language<\/h2>\n

    The #ifdef and #ifndef directives are conditional directives that depend on a previous definition. Let\u2019s see how the #ifdef directive works:<\/p>\n

    #define US<\/span>
    \n
    \n#ifdef US<\/span>
    \n
    \n\/\/If US is defined, the compiler will include this code in the compilation.<\/span><\/div><\/div>\n

    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.<\/p>\n

    #ifndef US<\/span>
    \n
    \n\/\/If US is NOT defined, the compiler will include this code in the compilation.<\/span><\/div><\/div>\n

    <\/a>
    \nHow to Use the #Ifdef and #Ifndef Directives in C Language<\/h2>\n

    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\u2019s see the C code for this program:<\/p>\n

    #include <stdio.h><\/span>
    \n
    \n\/\/Here we define which zone we are going to use. To use the LATAM zone uncomment the following line.<\/span>
    \n
    \n\/\/#define LATAM<\/span>
    \n
    \n#include "myheader.h"<\/span>
    \nvoid<\/span> main (<\/span>)<\/span>
    \n{<\/span>
    \nfloat<\/span> a,<\/span> b;<\/span>
    \n    printf<\/span><\/a> (<\/span>"%s"<\/span>,<\/span> in)<\/span>;<\/span>
    \n    scanf<\/span><\/a>  (<\/span>"%f"<\/span>,<\/span> &<\/span>a)<\/span>;<\/span>
    \n    printf<\/span><\/a> (<\/span>"%f (%f %s)\\n<\/span>"<\/span>,<\/span> a,<\/span> conv(<\/span>a)<\/span>,<\/span> unit_conv)<\/span>;<\/span>
    \nb=<\/span>(<\/span>a*<\/span>2<\/span>)<\/span>*<\/span>3.1416<\/span>;<\/span>
    \n    printf<\/span><\/a> (<\/span>out,<\/span> b,<\/span> conv(<\/span>b)<\/span>,<\/span> unit_conv)<\/span>;<\/span>
    \n}<\/span><\/div><\/div>\n

    As we can see, in this very simple code, we add the \u201cmyheader.h\u201d header which we save in the same directory where we have the \u201c.c\u201d file.<\/p>\n

    In the \u201cmyheader.h\u201d header, we use the #ifdef directive and write the code for LATAM in it. We do the same with the #ifndef directive in which we write the code for US. In each of these two directives, we define a macro function to convert the unit of measurement used in that area, as well as the constant strings that correspond to the language of the selected area. Let\u2019s see the code for this header:<\/p>\n

    #define MYHEADER_H<\/span>
    \n
    \n#ifdef LATAM<\/span>
    \n\/\/If LATAM is defined, the compiler will include this code in the compilation.<\/span>
    \n
    \n#define conv(b) b \/ 2.54<\/span>
    \nchar<\/span> in[<\/span>]<\/span>  =<\/span> "Zona Latino America\\n<\/span>Ingresar radio en cent\u00edmetros \\n<\/span>"<\/span>;<\/span>
    \nchar<\/span> unit_conv[<\/span>]<\/span>  =<\/span> "pulgadas"<\/span>;<\/span>
    \nchar<\/span> out[<\/span>]<\/span> =<\/span> "La circunferencia en pulgadas es %f (%f %s) \\n<\/span>Una pulgada equivale a 2.54cm\\n<\/span>"<\/span>;<\/span>
    \n#endif<\/span>
    \n
    \n#ifndef LATAM<\/span>
    \n\/\/If LATAM is NOT defined, the compiler will include this code in the compilation.<\/span>
    \n#define conv(b) b \/ 0.393701<\/span>
    \nchar<\/span> in[<\/span>]<\/span>  =<\/span> "Zone US\\n<\/span>Enter ratio in inches\\n<\/span>"<\/span>;<\/span>
    \nchar<\/span> unit_conv[<\/span>]<\/span>  =<\/span> "cm"<\/span>;<\/span>
    \nchar<\/span> out[<\/span>]<\/span> =<\/span> "The circumference in inches is %f (%f %s) \\n<\/span>One inch is equal to 2.54cm\\n<\/span>"<\/span>;<\/span>
    \n#endif<\/span><\/div><\/div>\n

    If LATAM is not defined in our code, the compiler defaults to compiling what is in the #ifndef directive, that is, the English-language strings. If LATAM is defined, it compiles the code corresponding to the #ifdef directive in which the strings are in Spanish. We insert this definition in the C code before the line that contains the \u201cmyheader.h\u201d header. Let\u2019s see how this code is compiled and executed by default:<\/p>\n

    <\/p>\n

     <\/p>\n

    Now, let’s uncomment the LATAM definition of our \u201cmain.c\u201d code and compile and run it again:<\/p>\n

    <\/p>\n

    As we can see, using the conditional directives, we can develop a single code to compile different versions of the same program, omitting unnecessary code that slows down the process and takes up the memory.<\/p>\n

    <\/a>The #If, #Elif, and #Else Directives in the C language<\/h2>\n

    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:<\/p>\n

    #define LATAM 1<\/span>
    \n#define FR    2<\/span>
    \n
    \n#define ZONE FR<\/span>
    \n
    \n#if ZONE == LATAM<\/span>
    \n
    \n\/\/If LATAM is defined, the compiler will include this code in the compilation.<\/span>
    \n
    \n#elif ZONE == FR<\/span>
    \n
    \n\/\/If FR is defined, the compiler will include this code in the compilation.<\/span>
    \n
    \n#else<\/span>
    \n
    \n\/\/If LATAM ot FR is not defined, the compiler will include this code in the compilation.<\/span>
    \n
    \n#endif<\/span><\/div><\/div>\n

    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.<\/p>\n

    <\/a>How to Use the #If, #Elif, and #Else Conditional Directives in the C Language<\/h2>\n

    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 \u201cmyheader.h\u201d file to add the French language to the program.<\/p>\n

    First, we define the FR, LATAM, and US constants and assign a value to each. Also, in the C code, before inserting the \u201cmyheader.h\u201d 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.<\/p>\n

    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.<\/p>\n

    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\u2019s see the code for the \u201cmyheader.h\u201d header:<\/p>\n

    #ifndef MYHEADER_H<\/span>
    \n#define MYHEADER_H<\/span>
    \n\/\/Here we define the constants with the options that we are going to use.<\/span>
    \n#define US          0<\/span>
    \n#define FR          1<\/span>
    \n#define LATAM       2<\/span>
    \n
    \n\/\/Here we define the compilation option for FR.<\/span>
    \n#if ZONE == FR<\/span>
    \n#define conv(b) b \/ 2.54<\/span>
    \nchar<\/span> in[<\/span>]<\/span>  =<\/span> "Zone France\\n<\/span>Entrez le rayon en pouces\\n<\/span>"<\/span>;<\/span>
    \nchar<\/span> unit_conv[<\/span>]<\/span>  =<\/span> "cm"<\/span>;<\/span>
    \nchar<\/span> out[<\/span>]<\/span> =<\/span> "La circonf\u00e9rence en pouces est %f (%f %s) \\n<\/span>Un pouce \u00e9quivaut \u00e0 2,54 cm"<\/span>;<\/span>
    \n
    \n\/\/Here we define the compilation option for LATAM.<\/span>
    \n#elif ZONE == LATAM<\/span>
    \n#define conv(b) b \/ 2.54<\/span>
    \nchar<\/span> in[<\/span>]<\/span>  =<\/span> "Zona Latino America\\n<\/span>Ingresar radio en cent\u00edmetros \\n<\/span>"<\/span>;<\/span>
    \nchar<\/span> unit_conv[<\/span>]<\/span>  =<\/span> "pulgadas"<\/span>;<\/span>
    \nchar<\/span> out[<\/span>]<\/span> =<\/span> "La circunferencia en pulgadas es %f (%f %s) \\n<\/span>Una pulgada equivale a 2.54cm"<\/span>;<\/span>
    \n
    \n\/\/Here we define the compilation option for the USA.<\/span>
    \n#else<\/span>
    \n#define conv(b) b \/ 0.393701<\/span>
    \nchar<\/span> in[<\/span>]<\/span>  =<\/span> "Zone US\\n<\/span>Enter ratio in inches\\n<\/span>"<\/span>;<\/span>
    \nchar<\/span> unit_conv[<\/span>]<\/span>  =<\/span> "cm"<\/span>;<\/span>
    \nchar<\/span> out[<\/span>]<\/span> =<\/span> "The circumference in inches is %f (%f %s)\\n<\/span>One inch is equal to 2.54cm"<\/span>;<\/span>
    \n
    \n#endif<\/span>
    \n#endif<\/span><\/div><\/div>\n

    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\u2019s see the code with the language options that are commented out so that the default zone, which is US, is compiled:<\/p>\n

    #include <stdio.h><\/span>
    \n
    \n\/\/Here we define which zone we are going to use.<\/span>
    \n#define ZONE US <\/span>
    \n\/\/#define ZONE LATAM<\/span>
    \n\/\/#define ZONE FR<\/span>
    \n#include "myheader.h"<\/span>
    \n
    \nvoid<\/span> main (<\/span>)<\/span>
    \n{<\/span>
    \nfloat<\/span> a,<\/span> b;<\/span>
    \n    printf<\/span><\/a> (<\/span>"%s"<\/span>,<\/span> in)<\/span>;<\/span>
    \n    scanf<\/span><\/a> (<\/span>"%f"<\/span>,<\/span> &<\/span>a)<\/span>;<\/span>
    \n    printf<\/span><\/a> (<\/span>"%f (%f %s)\\n<\/span>"<\/span>,<\/span> a,<\/span> conv(<\/span>a)<\/span>,<\/span> unit_conv)<\/span>;<\/span>
    \nb=<\/span>(<\/span>a*<\/span>2<\/span>)<\/span>*<\/span>3.1416<\/span>;<\/span>
    \n    printf<\/span><\/a> (<\/span>out,<\/span> b,<\/span> conv(<\/span>b)<\/span>,<\/span> unit_conv)<\/span>;<\/span>
    \n}<\/span><\/div><\/div>\n

    Let\u2019s see the execution of this code with its default US compilation:<\/p>\n

    <\/p>\n

     <\/p>\n

    <\/a>Now, we comment out the ZONE US definition and uncomment the ZONE LATAM definition, compile them, and run them again.<\/p>\n

    <\/a>Now, we comment out the ZONE definition and uncomment the ZONE FR definition, compile them, and run them again.<\/p>\n

    <\/a>In this way, we can use the #if, #elif, and #else conditional directives to specify the various compilation options by simply specifying the value of a constant.<\/p>\n

     <\/p>\n

    <\/a>#Error and #Warning Directives in the C Language<\/h2>\n

    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\u2019s see an example of the use of these two directives:<\/p>\n

    #include <stdio.h><\/span>
    \n
    \nvoid<\/span> main (<\/span>)<\/span>
    \n
    \n{<\/span>
    \n
    \n#error This is a test of the error directive.<\/span>
    \n
    \n#warning This is a test of the warning directive.<\/span>
    \n
    \n}<\/span><\/div><\/div>\n

    In the following figure, we will see the compilation of this code with the error and warning messages it contains:<\/p>\n

    <\/p>\n

     <\/p>\n

    <\/a>Conclusion<\/h2>\n

    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.<\/p>","protected":false},"excerpt":{"rendered":"

    Guide on what preprocessor directives in C are, how to use them, the directives available in C, their usefulness, and the practical examples on how they work.<\/p>","protected":false},"author":110,"featured_media":23305,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[168],"tags":[],"class_list":["post-23269","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting"],"_links":{"self":[{"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/posts\/23269","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/users\/110"}],"replies":[{"embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/comments?post=23269"}],"version-history":[{"count":0,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/posts\/23269\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/media\/23305"}],"wp:attachment":[{"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/media?parent=23269"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/categories?post=23269"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/tags?post=23269"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}