C Preprocessor Directives Practice Questions with Solutions

By /

The C Preprocessor is a program that processes source code before the actual compilation begins. It handles special commands called preprocessor directives, which always begin with the # symbol.

Preprocessor directives help automate many programming tasks such as including header files, defining constants, creating macros, conditional compilation, and preventing duplicate header inclusion.

Some commonly used preprocessor directives include:

  • #include – Includes header files.
  • #define – Defines constants and macros.
  • #undef – Removes a previously defined macro.
  • #ifdef – Checks whether a macro is defined.
  • #ifndef – Checks whether a macro is not defined.
  • #if, #elif, #else, #endif – Performs conditional compilation.
  • #pragma – Provides compiler-specific instructions.

Preprocessor directives are widely used in operating systems, embedded systems, device drivers, libraries, and large-scale software projects to improve code readability, maintainability, and reusability.

In this chapter, you’ll practice real-world preprocessor directive programs with complete solutions, sample outputs, explanations, and concepts covered. C Preprocessor Directives practice questions with solutions help to understand the concepts.

1. C Program to Use #define for a Constant

Problem Statement

Write a C program to define a constant using the #define directive.

C Solution

#include <stdio.h>

#define PI 3.14159

int main()
{
    float radius = 5;

    printf("Area of Circle = %.2f", PI * radius * radius);

    return 0;
}

Sample Output

Area of Circle = 78.54

Explanation

The #define directive creates a symbolic constant named PI, which replaces every occurrence of PI before compilation.

Concepts Covered

  • Preprocessor Directives
  • #define
  • Constants
  • Compile-Time Replacement

2. C Program to Create a Macro Using #define

Problem Statement

Write a C program to calculate the square of a number using a macro.

C Solution

#include <stdio.h>

#define SQUARE(x) ((x) * (x))

int main()
{
    int number = 8;

    printf("Square = %d", SQUARE(number));

    return 0;
}

Sample Output

Square = 64

Explanation

Macros allow reusable code without the overhead of function calls. The preprocessor replaces the macro before compilation.

Concepts Covered

  • Function-like Macros
  • #define
  • Code Reusability
  • Compile-Time Expansion

3. C Program to Include a Header File Using #include

Problem Statement

Write a C program demonstrating the use of the #include directive.

C Solution

#include <stdio.h>

int main()
{
    printf("Header File Included Successfully.");

    return 0;
}

Sample Output

Header File Included Successfully.

Explanation

The #include directive inserts the contents of the specified header file before compilation.

Concepts Covered

  • #include
  • Header Files
  • Standard Library
  • Preprocessor

4. C Program to Use #undef

Problem Statement

Write a C program to define a macro using #define and then remove it using #undef.

C Solution

#include <stdio.h>

#define VALUE 100

#undef VALUE

int main()
{
#ifdef VALUE
    printf("VALUE is Defined.");
#else
    printf("VALUE is Undefined.");
#endif

    return 0;
}

Sample Output

VALUE is Undefined.

Explanation

The #undef directive removes a previously defined macro. After removing it, the macro is no longer available for use in the program.

Concepts Covered

  • #define
  • #undef
  • Macro Management
  • Preprocessor Directives

5. C Program to Demonstrate #ifdef

Problem Statement

Write a C program to check whether a macro is defined using the #ifdef directive.

C Solution

#include <stdio.h>

#define LANGUAGE "C Programming"

int main()
{
#ifdef LANGUAGE
    printf("%s", LANGUAGE);
#else
    printf("Macro Not Defined.");
#endif

    return 0;
}

Sample Output

C Programming

Explanation

The #ifdef directive checks whether a macro exists. If it is defined, the corresponding block of code is compiled.

Concepts Covered

  • #ifdef
  • Conditional Compilation
  • Macros
  • Preprocessor

6. C Program to Demonstrate #ifndef

Problem Statement

Write a C program to demonstrate the use of the #ifndef directive.

C Solution

#include <stdio.h>

#ifndef VERSION
#define VERSION 1
#endif

int main()
{
    printf("Program Version = %d", VERSION);

    return 0;
}

Sample Output

Program Version = 1

Explanation

The #ifndef directive checks whether a macro is not defined. If the macro doesn’t exist, it defines it. This technique is commonly used in header guards to prevent multiple inclusions of the same header file.

Concepts Covered

  • #ifndef
  • Header Guards
  • Conditional Compilation
  • Preprocessor Directives

7. C Program to Use #if, #elif, #else, and #endif

Problem Statement

Write a C program to demonstrate conditional compilation using #if, #elif, #else, and #endif.

C Solution

#include <stdio.h>

#define NUMBER 10

int main()
{

#if NUMBER > 20

    printf("Number is Greater than 20.");

#elif NUMBER == 10

    printf("Number is Equal to 10.");

#else

    printf("Number is Less than 20.");

#endif

    return 0;
}

Sample Output

Number is Equal to 10.

Explanation

Conditional compilation allows specific blocks of code to be compiled based on compile-time conditions.

Concepts Covered

  • #if
  • #elif
  • #else
  • #endif
  • Conditional Compilation

8. C Program to Create a Maximum Number Macro

Problem Statement

Write a C program to find the larger of two numbers using a macro.

C Solution

#include <stdio.h>

#define MAX(a,b) ((a) > (b) ? (a) : (b))

int main()
{
    int firstNumber = 25;
    int secondNumber = 40;

    printf("Largest Number = %d",
           MAX(firstNumber, secondNumber));

    return 0;
}

Sample Output

Largest Number = 40

Explanation

Macros can simplify frequently used operations and improve code readability.

Concepts Covered

  • Macros
  • Conditional Operator
  • #define
  • Code Reusability

9. C Program to Swap Two Numbers Using Macros

Problem Statement

Write a C program to swap two numbers using a macro.

C Solution

#include <stdio.h>

#define SWAP(a,b) \
{                 \
    int temp;     \
    temp = a;     \
    a = b;        \
    b = temp;     \
}

int main()
{
    int firstNumber = 10;
    int secondNumber = 20;

    printf("Before Swap\n");
    printf("%d %d\n", firstNumber, secondNumber);

    SWAP(firstNumber, secondNumber);

    printf("After Swap\n");
    printf("%d %d",
           firstNumber,
           secondNumber);

    return 0;
}

Sample Output

Before Swap
10 20

After Swap
20 10

Explanation

The macro replaces the swapping code during preprocessing, eliminating the need for a function call.

Concepts Covered

  • Macros
  • Swapping
  • #define
  • Preprocessor

10. C Program to Calculate the Area of a Rectangle Using Macros

Problem Statement

Write a C program to calculate the area of a rectangle using a macro.

C Solution

#include <stdio.h>

#define AREA(length,width) ((length) * (width))

int main()
{
    int length = 12;
    int width = 8;

    printf("Area = %d",
           AREA(length, width));

    return 0;
}

Sample Output

Area = 96

Explanation

Macros provide a simple and efficient way to perform mathematical calculations during preprocessing.

Concepts Covered

  • Function-like Macros
  • #define
  • Mathematical Expressions
  • Compile-Time Expansion

11. C Program to Find the Minimum Number Using a Macro

Problem Statement

Write a C program to find the smaller of two numbers using a macro.

C Solution

#include <stdio.h>

#define MIN(a,b) ((a) < (b) ? (a) : (b))

int main()
{
    int firstNumber = 15;
    int secondNumber = 25;

    printf("Smallest Number = %d",
           MIN(firstNumber, secondNumber));

    return 0;
}

Sample Output

Smallest Number = 15

Explanation

The macro compares two values using the conditional operator and returns the smaller value.

Concepts Covered

  • Macros
  • Conditional Operator
  • #define
  • Compile-Time Expansion

12. C Program to Calculate the Cube of a Number Using a Macro

Problem Statement

Write a C program to calculate the cube of a number using a macro.

C Solution

#include <stdio.h>

#define CUBE(x) ((x) * (x) * (x))

int main()
{
    int number = 4;

    printf("Cube = %d", CUBE(number));

    return 0;
}

Sample Output

Cube = 64

Explanation

The macro replaces the expression before compilation, allowing mathematical operations without function calls.

Concepts Covered

  • Function-like Macros
  • Mathematical Macros
  • #define
  • Preprocessor

13. C Program to Demonstrate Nested Macros

Problem Statement

Write a C program to demonstrate nested macros.

C Solution

#include <stdio.h>

#define ADD(a,b) ((a) + (b))
#define SQUARE(x) ((x) * (x))

int main()
{
    int result;

    result = SQUARE(ADD(2,3));

    printf("Result = %d", result);

    return 0;
}

Sample Output

Result = 25

Explanation

Macros can be nested, allowing one macro to use another macro during preprocessing.

Concepts Covered

  • Nested Macros
  • Function-like Macros
  • Compile-Time Expansion
  • Code Reusability

14. C Program to Use the #pragma Directive

Problem Statement

Write a C program demonstrating the use of the #pragma directive.

C Solution

#include <stdio.h>

#pragma message("Compiling Program...")

int main()
{
    printf("Program Executed Successfully.");

    return 0;
}

Sample Output

Program Executed Successfully.

Note: Compiler behavior may vary. Some compilers display the pragma message during compilation, while others may ignore unsupported #pragma directives.

Explanation

The #pragma directive provides compiler-specific instructions. Different compilers support different pragma options.

Concepts Covered

  • #pragma
  • Compiler Directives
  • Preprocessor
  • Compilation

15. C Program to Demonstrate Header Guards

Problem Statement

Write a C program demonstrating the concept of header guards.

Example Header File

#ifndef STUDENT_H
#define STUDENT_H

void displayMessage();

#endif

Example Source File

#include <stdio.h>
#include "student.h"

void displayMessage()
{
    printf("Header Guard Example");
}

int main()
{
    displayMessage();

    return 0;
}

Sample Output

Header Guard Example

Explanation

Header guards prevent a header file from being included multiple times in the same program, avoiding compilation errors caused by duplicate declarations.

Concepts Covered

  • Header Guards
  • #ifndef
  • #define
  • #endif
  • Multiple Inclusion Protection

Chapter Summary

In this chapter, you learned how preprocessor directives improve the flexibility, readability, and maintainability of C programs. You practiced using #include, #define, #undef, conditional compilation directives (#ifdef, #ifndef, #if, #elif, #else, #endif), macros, nested macros, #pragma, and header guards. These concepts are widely used in large-scale software development, embedded systems, operating systems, and reusable C libraries.

Key Takeaways

  • Preprocessor directives execute before compilation begins.
  • #include inserts the contents of header files.
  • #define creates symbolic constants and reusable macros.
  • #undef removes previously defined macros.
  • #ifdef and #ifndef support conditional compilation.
  • #if, #elif, #else, and #endif compile code based on conditions.
  • Function-like macros simplify repetitive calculations.
  • Nested macros improve code reusability.
  • #pragma provides compiler-specific instructions.
  • Header guards prevent multiple inclusion of header files.

Frequently Asked Questions (FAQs)

1. What is a preprocessor directive in C?

A preprocessor directive is a command that is processed before the C compiler begins compilation. All preprocessor directives start with the # symbol.

2. What is the purpose of #define?

#define is used to create constants and macros that are replaced before compilation.

3. What is a macro in C?

A macro is a reusable piece of code created using #define. It is expanded by the preprocessor before compilation.

4. What is conditional compilation?

Conditional compilation allows specific sections of code to be compiled only when certain conditions are satisfied using directives like #ifdef, #ifndef, and #if.

5. What is the purpose of #pragma?

#pragma provides compiler-specific instructions such as optimization settings, warning control, and diagnostic messages.

6. What are header guards?

Header guards prevent a header file from being included multiple times, avoiding duplicate declarations and compilation errors.

7. Why are macros faster than functions?

Macros are expanded during preprocessing, eliminating the overhead of function calls. However, they should be used carefully because they do not perform type checking.

8. Where are preprocessor directives used in real-world programming?

Preprocessor directives are extensively used in embedded systems, operating systems, reusable libraries, device drivers, networking software, game engines, and large enterprise applications to improve modularity, portability, and maintainability.

Written by Shubhranshu Shekhar, who has trained 20000+ students in coding.

Related Posts

Scroll to Top