{"id":81477,"date":"2021-07-06T09:00:57","date_gmt":"2021-07-06T03:30:57","guid":{"rendered":"https:\/\/techvidvan.com\/tutorials\/?p=81477"},"modified":"2021-07-06T09:00:57","modified_gmt":"2021-07-06T03:30:57","slug":"preprocessors-in-c","status":"publish","type":"post","link":"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/","title":{"rendered":"Preprocessors in C"},"content":{"rendered":"

In C, preprocessors are one of the most important and useful concepts. Preprocessor allows you to define macros that transform your program before it is compiled. C preprocessor is also known as CPP.<\/p>\n

\"working<\/a><\/p>\n

What are preprocessor in C?<\/h3>\n

C preprocessors tell the compiler to do the required processing before its compilation. From the word \u2018preprocessor\u2019, you already know the meaning of it. \u2018Pre\u2019 means before<\/strong> and \u2018processor\u2019 means making something<\/strong>. It is not part of the compiler but it is considered as a separate step in the compilation process.<\/p>\n

Suppose, we have a c file named main.c with extension of .c. Preprocessors then process this file and in the next step, it gets compiled and it produces an object file with extension of .obj. After that the .obj<\/strong> file is linked with standard library functions to generate a file with extension of .exe<\/strong> and then it executes.<\/p>\n

What are C Preprocessor directives?<\/h3>\n

It tells the compiler to preprocess the source code before compiling. Preprocessor Directives mainly used as commands. In C, all the preprocessor directives start with a hash\/pound(#)<\/strong> symbol. You can use preprocessor directives anywhere in the program. But it is best to use the preprocessor directives at the beginning of the program.<\/p>\n

Example:-<\/strong><\/p>\n

#define PI 3.14<\/pre>\n
Types of Preprocessor in C<\/h3>\n
There are 4 main types of preprocessor directives:-<\/p>\n
    \n
  • Macros<\/li>\n
  • File Inclusion<\/li>\n
  • Conditional Compilation<\/li>\n
  • Other directives<\/li>\n<\/ul>\n
    1. Macros in C<\/h3>\n
    Programmers use macros to execute pieces of code inside the macro. A programmer gives a name to the macro. And when the given name is encountered by the compiler then the compiler replaces the name with the piece of code which is inside the macro. The #define<\/strong> directive is used to define a macro.<\/p>\n
    Example of C Macros<\/strong><\/p>\n
    #include <stdio.h>\n#define LIMIT 4 \/\/ defining macro!\nint main()\n{\nfor (int a = 0; a < LIMIT; a++) {\nprintf(\"%d \\n\",a);\n}\nreturn 0;\n}\n<\/pre>\n
    Output<\/strong><\/p>\n
    0
    \n1
    \n2
    \n3<\/div>\n
    In the above example, the compiler replaces LIMIT with 5. LIMIT<\/strong> is a macro template and 5<\/strong>\u00a0 is macro expansion.<\/p>\n
    Macros with arguments<\/h4>\n
    We can also pass arguments to the macros. Macros with arguments work similarly as functions.<\/p>\n
    Example of Macros with arguments:-<\/strong><\/p>\n
    #include <stdio.h>\n#define AREA(s) (s * s) \/\/ macro with argument\nint main()\n{\nint s1 = 10, area_of_square;\narea_of_square = AREA(s1);\nprintf(\"TechVidvan Tutorial: Macros with arguments!\\n\");\nprintf(\"Area of square is: %d\", area_of_square);\nreturn 0;\n}<\/pre>\n
    Output<\/strong><\/p>\n
    TechVidvan Tutorial: Macros with arguments!
    \nArea of square is: 100<\/div>\n
    In the above example, the compiler finds the name of the macro (AREA(s))<\/strong> and replaces it with the statement (s * s)<\/strong>.<\/p>\n
    Function like Macros in C<\/h4>\n
    Define macros that work similarly like functions.<\/p>\n
    Example of Function like Macros in C<\/strong><\/p>\n
    #include <stdio.h>\n\n#define MIN(a,c) ((a) > (c) ? (c) : (a))\n\nint main(void) {\n   printf(\"Between 30 and 70, minimum number is: %d\\n\", MIN(10, 20));  \n   return 0;\n}\n<\/pre>\n
    Output<\/strong><\/p>\n
    Between 30 and 70, minimum number is: 10<\/div>\n
    2. File Inclusion<\/h3>\n
    This preprocessor directive tells the compiler to include a file in the program code. A user can include two types of file:-<\/p>\n
    a. Header or Standard files<\/h4>\n
    These files contain functions like printf(), scanf(). In a single word, it contains predefined functions. Different header files contain different functions. Like, string<\/strong> file contains string handling functions and iostream<\/strong> file contains input\/output functions.<\/p>\n
    Syntax:-<\/strong><\/p>\n
    #include <name_of_the_file><\/pre>\n
    b. user defined files<\/h4>\n
    A programmer can define his\/her own header file to divide a complex code into small blocks of code.<\/p>\n
    Syntax:-<\/strong><\/p>\n
    #include\"filename\"<\/pre>\n
    3. Conditional Compilation in C<\/h3>\n
    The main purpose of this preprocessor directive is to compile specific parts of the code or skip the compilation of specific parts of the code based upon some conditions.<\/p>\n
    How to use conditional compilation directives?<\/h4>\n
    With the help of two preprocessing methods, you can implement the conditional compilation directive.<\/p>\n
      \n
    • ifdef<\/strong><\/li>\n
    • endif<\/strong><\/li>\n<\/ul>\n
      Syntax:-<\/strong><\/p>\n
      #ifdef macro_name\n    statement1;\n    statement2;\n    statement3;\n    .\n    .\n    .\n    statementN;\n#endif\n<\/pre>\n
      If the macro name is defined, then it will normally execute the block of statements. And if it is not defined, then the compiler will skip the block of statements.<\/p>\n
      Apart from #ifdef<\/strong> and #endif<\/strong> directives, there are some other directives such as #if, #elif, #else<\/strong> and #defined<\/strong> directives.<\/p>\n
      #if, #elif, #else directive in C<\/h4>\n
      You can also use #else<\/strong> directive with #if<\/strong> directive. If the given expression results in a non zero value, then the codes of conditional are included in the program.<\/p>\n
      Syntax:-<\/strong><\/p>\n
      #if expression\n\/\/ conditional statements if expression is not zero\n#else\n\/\/ conditional statements if expression is zero\n#endif\n<\/pre>\n
      You can also use nested conditional in your program with the help of #elif<\/strong> directive.<\/p>\n
      Syntax:-<\/strong><\/p>\n
      #if expression1\n\/\/ conditional statements if expression1 is not zero\n#elif expression2\n\/\/ conditional statements if expression1 is not zero\n#else\n\/\/ conditional statements if all expressions is zero\n#endif\n<\/pre>\n
      #defined directive in C<\/h4>\n
      Mainly used to check whether a certain macro is defined or not. You can use #if<\/strong> directive with #defined<\/strong> directive.<\/p>\n
      Syntax:-<\/strong><\/p>\n
      #if defined LENGTH || WIDTH >= 10\n  \/\/ body contains code\n<\/pre>\n
      Uses of C Conditional Compilation:-<\/h4>\n
        \n
      • Compile the same source file in different programs.<\/li>\n
      • Depending on the OS, you can use different code.<\/li>\n<\/ul>\n
        4. Other directives in C<\/h3>\n
        There are also two not so used directives available in C.<\/p>\n
        a. #undef directive:-<\/strong> Mainly used to undefine an existing macro.<\/p>\n
        Syntax:-<\/strong><\/p>\n
        #undef LIMIT<\/pre>\n
        If you use the above statement then it will undefine the existing macro LIMIT.<\/p>\n
        b. #pragma directive:-<\/strong> Mainly used to enable or disable certain features. It varies from compiler to compiler. Below is some of the pragma directives:-<\/p>\n
          \n
        • #pragma startup and #pragma exit:<\/strong>– Mainly used to specify the functions which are needed to run before program startup and before program exit.<\/li>\n<\/ul>\n
          Example:- pragma startup and pragma exit<\/strong><\/p>\n
          #include <stdio.h>\nvoid f1();\nvoid f2();\n#pragma startup f1\n#pragma exit f2\nvoid f1()\n{\n  printf(\"Executing f1() function!\\n\");\n}\n \nvoid f2()\n{\n  printf(\"Executing f2() function!\\n\");\n}\n \nint main()\n{\n  void f1();\n  void f2();\n  printf(\"TechVidvan Tutorial: pragma startup and pragma exit!\\n\\n\");\n  printf(\"Executing main() function!\\n\");\n \n  return 0;\n}\n<\/pre>\n
          Output<\/strong><\/p>\n
          \n
          TechVidvan Tutorial: pragma startup and pragma exit!<\/p>\n
          Executing f1() function!
          \nExecuting main function!
          \nExecuting f2() function!<\/p>\n<\/div>\n
          But if you run this in GCC compiler, it will give output like this:-<\/p>\n
          \n
          TechVidvan Tutorial: pragma startup and pragma exit!<\/p>\n
          Executing main function!<\/p>\n<\/div>\n
          Because GCC compiler does not support #pragma startup or #pragma exit.<\/p>\n
            \n
          • #pragma warn directive:-<\/strong> Mainly used to hide warning messages that are displayed while compilation.<\/li>\n
          • #pragma warn -rvl:-<\/strong> Mainly used to hide the warnings when a function does not return a value as it is supposed to.<\/li>\n
          • #pragma warn -par:-<\/strong> Mainly used to hide the warnings when a function does not use the parameters which are passed to it.<\/li>\n
          • #pragma warn -rch:-<\/strong> Mainly used to hide the warnings when a code is unreachable.<\/li>\n<\/ul>\n
            C Preprocessor Examples:-<\/h4>\n
            Below are some examples of preprocessors:-<\/p>\n
            #define SIZE 42<\/pre>\n
            In the above example, the compiler will automatically replace the macro name SIZE with 42.<\/p>\n
            #include <string.h>\n#include \"header.h\"\n<\/pre>\n
            In the above example, we added the string.h<\/strong> header file to make use of string handling functions. And also, we added our own header.h file from the local directory.<\/p>\n
            #undef TEST<\/pre>\n
            It tells the compiler to undefine existing TEST.<\/strong><\/p>\n
            #ifndef MOTD\n   #define MOTD \"TechVidvan Tutorial: P\"\n#endif\nIn the above example\n<\/pre>\n
            In the above example, we have defined MOTD<\/strong> only if MOTD<\/strong> is not defined already. MOTD<\/strong> means message of the day.<\/p>\n
            How does a preprocessor work in C?<\/h3>\n
            Below are the steps involved while preprocessing:-<\/p>\n
            1. Filtering out comments:<\/strong>– In C, comments are used for better understanding of different steps which are included in the program. Compiler filters out the comments during processing.<\/p>\n
            2. File Inclusion:<\/strong>– It tells the compiler to include certain header files so that certain functions can be performed. In 2 ways, you can do it:-<\/p>\n
              \n
            • #include<filename.h><\/li>\n
            • #include\u201dfilename.h\u201d<\/li>\n<\/ul>\n
              3. Macro Expansion:<\/strong>– In some situations, you will need to use some blocks of code in a recursive function. In 2 ways, you can do it:-<\/p>\n
              4. Object-like macros:<\/strong>– Does not take parameters.<\/p>\n
              5. Function-like macros:<\/strong>– Capable of taking parameters.<\/p>\n
              Example of Object-like Macros<\/strong><\/p>\n
              #include <stdio.h>\n#define SIDE 4\nint main() {\n  int area;\n  area = SIDE*SIDE;\n  printf(\"TechVidvan Tutorial: Object Like Macros!\\n\");\n  printf(\"Area is: %d\",area);\n  return 0;\n}\n<\/pre>\n
              Output<\/strong><\/p>\n
              TechVidvan Tutorial: Object Like Macros!
              \nArea is: 16<\/div>\n
              In the above example, SIDE<\/strong> is the macro name and it will be replaced by value 4<\/strong>.<\/p>\n
              Below is a table of preprocessor in C:-<\/strong><\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
              Preprocessor<\/b><\/td>\nWhat it does<\/b><\/td>\n<\/tr>\n
              #include<\/span><\/td>\nTo insert a specific header from a file.<\/span><\/td>\n<\/tr>\n
              #define<\/span><\/td>\nMainly used as a replacement of a preprocessor macro.<\/span><\/td>\n<\/tr>\n
              #ifdef<\/span><\/td>\nIf the macro is defined, it returns true. And if not, then false.<\/span><\/td>\n<\/tr>\n
              #endif<\/span><\/td>\nMainly used to close the preprocessor directive.<\/span><\/td>\n<\/tr>\n
              #undef<\/span><\/td>\nTo undefine a standard or user-defined header.<\/span><\/td>\n<\/tr>\n
              #pragma<\/span><\/td>\nTo enable and disable certain features.<\/span><\/td>\n<\/tr>\n
              #ifndef<\/span><\/td>\nReturns true when micro is not defined.<\/span><\/td>\n<\/tr>\n
              #if<\/span><\/td>\nChecks if the condition is true at compile time.<\/span><\/td>\n<\/tr>\n
              #else<\/span><\/td>\nChecks the next condition if #if proves to be false in compile time.<\/span><\/td>\n<\/tr>\n
              #elif<\/span><\/td>\nUsed as a combination of #else and #if.<\/span><\/td>\n<\/tr>\n
              #error<\/span><\/td>\nMainly used to print errors on stderr.<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
              Predefined Macros in C<\/strong><\/h4>\n
              One should not modify the predefined macros. Below are some predefined macros.<\/p>\n\n\n\n\n\n\n\n\n
              MACRO\u00a0<\/b><\/td>\nWhat it does<\/b><\/td>\n<\/tr>\n
              __DATE__<\/span><\/td>\nCurrent date as MMM DD YYYY format.<\/span><\/td>\n<\/tr>\n
              __TIME__<\/span><\/td>\nCurrent time as HH:MM:SS format.<\/span><\/td>\n<\/tr>\n
              __FILE__<\/span><\/td>\nContains current filename.<\/span><\/td>\n<\/tr>\n
              __LINE__\u00a0<\/span><\/td>\nContains current line number.<\/span><\/td>\n<\/tr>\n
              __STDC__<\/span><\/td>\nDefined as 1 when the compiler compiles.<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
              Example of C Predefined Macros<\/strong><\/p>\n
              #include <stdio.h>\nint main() {\nprintf(\"TechVidvan Tutorial: Predefined Macros!\\n\\n\");\nchar filename[] = __FILE__;\nchar date[] = __DATE__;\nchar time[] = __TIME__;\nint line = __LINE__;\nint ansi = __STDC__;\nprintf(\"File name is: %s\\n\", filename);\nprintf(\"Date is: %s\\n\", date);\nprintf(\"Now time is: %s\\n\", time);\nprintf(\"Current line number: %d\\n\", line);\nprintf(\"Compilation Success: %d\\n\", ansi);\n}\n<\/pre>\n
              The above code is saved in a file named HelloWorld.c.<\/strong><\/p>\n
              Output:-<\/strong><\/p>\n
              \n
              TechVidvan Tutorial: Predefined Macros!<\/p>\n
              File name is: main.c
              \nDate is: Jun 11 2021
              \nNow time is: 08:58:39
              \nCurrent line number: 7
              \nCompilation Success: 1<\/p>\n<\/div>\n
              Preprocessor Operators in C<\/h3>\n
              There are various operators that help to create macros.<\/p>\n
              1. Macro Continuation(\/) operator in C<\/h4>\n
              Mainly used to continue a macro which is too long to a single line.<\/p>\n
              Example:- Macro Continuation<\/strong><\/p>\n
              #define  message_of_the_day(i, j)  \\\n   printf(#i \" and \" #j \": TechVidvan Tutorial: Macro Continuation!\")\n<\/pre>\n
              2. Stringize Operator(#) in C<\/h4>\n
              The main purpose of this operator is to convert a macro parameter into a string.<\/p>\n
              Example of Stringize Operator<\/strong><\/p>\n
              #include <stdio.h>\n#define statement(i)  \\\n  printf(#i \": Macro Stringize!\\n\")\n \nint main(void) {\n   statement(TechVidvan Tutorial);\n   return 0;\n}\n<\/pre>\n
              Output:-<\/strong><\/p>\n
              TechVidvan Tutorial: Macro Stringize!<\/div>\n
              3. Defined() Operator in C<\/h4>\n
              Mainly used to determine if an identifier is defined. If it is defined, then the value will be non-zero.<\/p>\n
              Example:- Defined() Operator<\/strong><\/p>\n
              #include <stdio.h>\n#if !defined (MSG)\n   #define MSG \"Macro Defined() operator!\"\n#endif\n\nint main(void) {\n   printf(\"TechVidvan Tutorial: %s\\n\", MSG);  \n   return 0;\n}\n<\/pre>\n
              Output:-<\/strong><\/p>\n
              TechVidvan Tutorial: Macro Defined() operator!<\/div>\n
              4. Token Pasting(##) Operator in C<\/h4>\n
              Mainly used to combine two arguments.<\/p>\n
              Example:- Macro Token Pasting<\/strong><\/p>\n
              #include <stdio.h>\n#define tokenpaster(num) printf (\"token\" #num \" = %d\", token##num)\nint main(void) {\nint token1 = 21;\nprintf(\"TechVidvan Tutorial: Token Pasting(##) operator\\n\\n\");\n   tokenpaster(1);\n   return 0;\n}\n<\/pre>\n
              Output<\/strong><\/p>\n
              \n
              TechVidvan Tutorial: Token Pasting(##) operator<\/p>\n
              token1 = 21<\/p>\n<\/div>\n
              Summary<\/h3>\n
              There are 4 main types of preprocessor directives in C. Preprocessor allows you to define macros that transform your program before it is compiled.<\/p>\n
              Programmers use macros to execute pieces of code inside the macro. The #define directive is used to define a macro. \u2018Pre\u2019 means before and \u2018processor\u2019 means making something.<\/p>\n","protected":false},"excerpt":{"rendered":"
              In C, preprocessors are one of the most important and useful concepts. Preprocessor allows you to define macros that transform your program before it is compiled. C preprocessor is also known as CPP. What...<\/p>\n","protected":false},"author":1,"featured_media":81689,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3510],"tags":[3729,3730,3731,3732,3733,3734],"class_list":["post-81477","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-programming","tag-conditional-compilation-in-c","tag-file-inclusion-in-c","tag-macros-in-c","tag-preprocessor-directives-in-c","tag-preprocessors-in-c","tag-types-of-preprocessor-in-c"],"yoast_head":"\nPreprocessors in C - TechVidvan<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Preprocessors in C - TechVidvan\" \/>\n<meta property=\"og:description\" content=\"In C, preprocessors are one of the most important and useful concepts. Preprocessor allows you to define macros that transform your program before it is compiled. C preprocessor is also known as CPP. What...\" \/>\n<meta property=\"og:url\" content=\"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/\" \/>\n<meta property=\"og:site_name\" content=\"TechVidvan\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/TechVidvan\/\" \/>\n<meta property=\"article:published_time\" content=\"2021-07-06T03:30:57+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2021\/06\/Preprocessors-in-C.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"628\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"TechVidvan Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@vidvantech\" \/>\n<meta name=\"twitter:site\" content=\"@vidvantech\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"TechVidvan Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"9 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Preprocessors in C - TechVidvan","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/","og_locale":"en_US","og_type":"article","og_title":"Preprocessors in C - TechVidvan","og_description":"In C, preprocessors are one of the most important and useful concepts. Preprocessor allows you to define macros that transform your program before it is compiled. C preprocessor is also known as CPP. What...","og_url":"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/","og_site_name":"TechVidvan","article_publisher":"https:\/\/www.facebook.com\/TechVidvan\/","article_published_time":"2021-07-06T03:30:57+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2021\/06\/Preprocessors-in-C.jpg","type":"image\/jpeg"}],"author":"TechVidvan Team","twitter_card":"summary_large_image","twitter_creator":"@vidvantech","twitter_site":"@vidvantech","twitter_misc":{"Written by":"TechVidvan Team","Est. reading time":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/#article","isPartOf":{"@id":"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/"},"author":{"name":"TechVidvan Team","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/person\/e9c26e74dd3d87421f7ada9433b8cd22"},"headline":"Preprocessors in C","datePublished":"2021-07-06T03:30:57+00:00","mainEntityOfPage":{"@id":"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/"},"wordCount":1533,"commentCount":0,"publisher":{"@id":"https:\/\/techvidvan.com\/tutorials\/#organization"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/#primaryimage"},"thumbnailUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2021\/06\/Preprocessors-in-C.jpg","keywords":["Conditional Compilation in C","File Inclusion in C","Macros in C","Preprocessor directives in C","Preprocessors in C","Types of Preprocessor in C"],"articleSection":["C Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/","url":"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/","name":"Preprocessors in C - TechVidvan","isPartOf":{"@id":"https:\/\/techvidvan.com\/tutorials\/#website"},"primaryImageOfPage":{"@id":"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/#primaryimage"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/#primaryimage"},"thumbnailUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2021\/06\/Preprocessors-in-C.jpg","datePublished":"2021-07-06T03:30:57+00:00","breadcrumb":{"@id":"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/#primaryimage","url":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2021\/06\/Preprocessors-in-C.jpg","contentUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2021\/06\/Preprocessors-in-C.jpg","width":1200,"height":628,"caption":"Preprocessors in C"},{"@type":"BreadcrumbList","@id":"https:\/\/techvidvan.com\/tutorials\/preprocessors-in-c\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/techvidvan.com\/tutorials\/"},{"@type":"ListItem","position":2,"name":"Preprocessors in C"}]},{"@type":"WebSite","@id":"https:\/\/techvidvan.com\/tutorials\/#website","url":"https:\/\/techvidvan.com\/tutorials\/","name":"TechVidvan Blogs","description":"","publisher":{"@id":"https:\/\/techvidvan.com\/tutorials\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/techvidvan.com\/tutorials\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/techvidvan.com\/tutorials\/#organization","name":"TechVidvan","url":"https:\/\/techvidvan.com\/tutorials\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/logo\/image\/","url":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2024\/03\/techvidvan-logo-200x50-1.webp","contentUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2024\/03\/techvidvan-logo-200x50-1.webp","width":200,"height":50,"caption":"TechVidvan"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/TechVidvan\/","https:\/\/x.com\/vidvantech"]},{"@type":"Person","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/person\/e9c26e74dd3d87421f7ada9433b8cd22","name":"TechVidvan Team","description":"The TechVidvan Team delivers practical, beginner-friendly tutorials on programming, Java, Python, C++, DSA, AI, ML, data Science, Android, Flutter, MERN, Web Development, and technology. Our experts are here to help you upskill and excel in today\u2019s tech industry."}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts\/81477","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/comments?post=81477"}],"version-history":[{"count":0,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts\/81477\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/media\/81689"}],"wp:attachment":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/media?parent=81477"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/categories?post=81477"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/tags?post=81477"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}