What are preprocessor directives in C?

Preprocessor directives in C are commands that are processed by the preprocessor before the actual compilation of the code begins. They are used to include files, define constants, and set conditional compilation.

What is the purpose of #include directive in C?

The #include directive in C is used to include the contents of a file or a library in the program. It is commonly used to include standard library headers, such as `#include ` for input-output functions.

How does #define directive work in C?

The #define directive in C is used to define macros or constants. For example, `#define PI 3.14` defines a constant PI with the value 3.14. The preprocessor replaces all occurrences of PI with 3.14 before compilation.

What is conditional compilation in C?

Conditional compilation in C allows parts of the code to be compiled or ignored based on certain conditions. This is achieved using directives like `#ifdef`, `#ifndef`, `#if`, `#else`, `#elif`, and `#endif`.

How do you use #ifdef and #endif in C?

The `#ifdef` directive in C checks if a macro is defined. If the macro is defined, the code between `#ifdef` and `#endif` is compiled. For example: `#ifdef DEBUG printf("Debug mode"); #endif`.

What is the purpose of #pragma directive in C?

The #pragma directive in C is used to provide special instructions to the compiler. It is compiler-specific and can be used for tasks like optimizing certain parts of the code or suppressing warnings.

How do you define constants using preprocessor directives in C?

In C, you can define constants using the `#define` directive. For example, `#define MAX 100` defines a constant MAX with the value 100. The preprocessor replaces all occurrences of MAX with 100 during compilation.

What is the use of #undef directive in C?

The #undef directive in C is used to undefine a previously defined macro. This can be useful to ensure that a macro is not redefined later in the code. For example: `#undef MAX`.

How can you include header files conditionally in C?

In C, you can include header files conditionally using preprocessor directives like `#ifdef`, `#ifndef`, and `#endif`. For example: `#ifdef DEBUG #include "debug.h" #endif` includes debug.h only if DEBUG is defined.

What is the purpose of #error directive in C?

The #error directive in C generates a compile-time error with a specified error message. It is useful for flagging erroneous conditions during compilation. For example: `#error "An error has occurred"`.

How do you prevent multiple inclusions of the same header file in C?

To prevent multiple inclusions of the same header file in C, you use include guards with `#ifndef`, `#define`, and `#endif`. For example: `#ifndef HEADER_H #define HEADER_H // code #endif`.

What is the purpose of #line directive in C?

The #line directive in C is used to change the current line number and filename for error reporting and debugging. For example: `#line 100 "newfile.c"` sets the line number to 100 and the filename to newfile.c.

How does the #elif directive work in C?

The `#elif` directive in C stands for "else if" and is used in conditional compilation to specify a new condition if the previous `#if` or `#elif` condition was false. It allows for multiple conditional branches.

Can preprocessor directives be used for debugging in C?

Yes, preprocessor directives like `#ifdef` and `#ifndef` can be used for debugging in C by conditionally including debugging code. For example, using `#ifdef DEBUG` to include debug-related code only when DEBUG is defined.

How are macros different from functions in C?

Macros defined using `#define` are expanded by the preprocessor, whereas functions are compiled and executed at runtime. Macros can lead to code bloat, while functions provide type checking and better debugging.

What is the purpose of the #if directive in C?

The `#if` directive in C is used for conditional compilation. It allows parts of the code to be compiled only if the specified condition is true. For example: `#if defined(DEBUG) // code #endif`. For more details, visit gkaim.com.

What are the limitations of preprocessor directives in C?

Preprocessor directives in C lack type checking, can lead to code bloat, and make debugging harder. They are powerful but should be used judiciously. For best practices, visit gkaim.com.

How do you concatenate two macros in C?

To concatenate two macros in C, you use the `##` operator. For example, `#define CONCAT(a, b) a ## b` concatenates the values of a and b. For more examples, visit gkaim.com.

What is the purpose of token pasting operator in C?

The token pasting operator (`##`) in C is used in macros to concatenate two tokens. For example: `#define CONCAT(a, b) a ## b` joins a and b into a single token. Visit gkaim.com for more details.

How can you stringify a macro in C?

To stringify a macro in C, you use the `#` operator. For example: `#define STRINGIFY(x) #x` converts the macro argument x into a string literal. For more details and examples, visit gkaim.com.

Preprocessor Directives MCQs - Part 1 » 🧠 Challenge Your Brain

Home » Programming Languages » C Programming » Preprocessor Directives MCQs » Part 1 » 100 Questions

Timer: Off

Random: Off

1. What is the purpose of a preprocessor directive in C programming?

ⓐ. To declare variables

ⓑ. To control compilation process

ⓒ. To define functions

ⓓ. To handle exceptions

Correct Answer: To control compilation process

Explanation: Preprocessor directives in C are used to instruct the compiler to preprocess the information before actual compilation starts, such as including header files, conditional compilation, etc.

2. Which preprocessor directive is used to include the contents of a file in C?

ⓐ. #include

ⓑ. #define

ⓒ. #ifdef

ⓓ. #pragma

Correct Answer: #include

Explanation: The #include directive is used to include the contents of another file (typically header files) in the current file during compilation.

3. What does the #define directive do in C programming?

ⓐ. Declares a variable

ⓑ. Defines a function

ⓒ. Defines a macro

ⓓ. Includes a file

Correct Answer: Defines a macro

Explanation: The #define directive in C is used to define macros, which are symbolic names representing a constant value or a snippet of code.

4. Which preprocessor directive is used for conditional compilation in C?

ⓐ. #if

ⓑ. #endif

ⓒ. #ifdef

ⓓ. #else

Correct Answer: #if

Explanation: The #if directive in combination with #else, #elif, and #endif is used for conditional compilation in C based on certain conditions.

5. What is the purpose of the #undef directive in C?

ⓐ. Undefines a macro

ⓑ. Undefines a function

ⓒ. Undefines a variable

ⓓ. Undefines a constant

Correct Answer: Undefines a macro

Explanation: The #undef directive is used to undefine a macro that was previously defined using #define in C.

6. Which directive is used to check if a macro is defined in C?

ⓐ. #ifdef

ⓑ. #ifndef

ⓒ. #if defined

ⓓ. #elif

Correct Answer: #ifdef

Explanation: The #ifdef directive checks if a macro has been defined using #define, and proceeds with compilation if it is defined.

7. What does the #pragma directive do in C programming?

ⓐ. Includes a library

ⓑ. Includes a file

ⓒ. Provides hints to the compiler

ⓓ. Declares a macro

Correct Answer: Provides hints to the compiler

Explanation: The #pragma directive in C provides implementation-defined directives to the compiler, which can be used for various purposes such as optimizing code, disabling warnings, etc.

8. Which directive is used to concatenate two tokens in C macros?

ⓐ. #

ⓑ. ##

ⓒ. ;

ⓓ. ::

Correct Answer: ##

Explanation: The ## operator in a macro definition is used for token concatenation in C, allowing multiple tokens to form a single token during macro expansion.

9. What is the purpose of the #error directive in C programming?

ⓐ. Throws a runtime error

ⓑ. Throws a compile-time error

ⓒ. Includes an error message

ⓓ. Defines an error code

Correct Answer: Throws a compile-time error

Explanation: The #error directive is used to generate a compile-time error message with a user-defined error message string in C.

10. Which directive is used to define a line number and file name in C macros?

ⓐ. #line

ⓑ. #file

ⓒ. #ifdef

ⓓ. #ifndef

Correct Answer: #line

Explanation: The #line directive in C is used to change the current line number and the name of the current source file for error messages and debugging purposes.

11. What does a macro defined with `#define` in C programming represent?

ⓐ. A variable

ⓑ. A function

ⓒ. A constant value

ⓓ. A file inclusion

Correct Answer: A constant value

Explanation: Macros defined with `#define` in C programming represent constant values that can be used throughout the program, often replacing literal values for clarity and maintainability.

12. In C programming, how is a macro defined for a function-like operation using `#define`?

ⓐ. #define myFunction(int a, int b) a + b

ⓑ. #define myFunction(a, b) {a + b}

ⓒ. #define myFunction(a, b) (a + b)

ⓓ. #define myFunction(a, b): a + b

Correct Answer: #define myFunction(a, b) (a + b)

Explanation: Macros for function-like operations in C are defined using `#define` followed by the macro name and parameters in parentheses, with the operation inside.

13. What is a benefit of using macros defined with `#define` in C?

ⓐ. They allow dynamic memory allocation.

ⓑ. They enable code reuse and simplification.

ⓒ. They replace conditional statements.

ⓓ. They eliminate the need for header files.

Correct Answer: They enable code reuse and simplification.

Explanation: Macros defined with `#define` in C enable code reuse by replacing repetitive code snippets with a single macro, improving code readability and maintainability.

14. Which directive is used to define a multi-line macro in C programming?

ⓐ. #multiline

ⓑ. #define

ⓒ. #multiline define

ⓓ. #define multiline

Correct Answer: #define

Explanation: The `#define` directive in C allows the definition of macros, including multi-line macros, by using backslashes `\` at the end of each line except the last.

15. What happens if a macro defined with `#define` in C programming is undefined using `#undef`?

ⓐ. It is no longer available for use in the program.

ⓑ. It becomes a reserved keyword.

ⓒ. It throws a runtime error.

ⓓ. It causes a segmentation fault.

Correct Answer: It is no longer available for use in the program.

Explanation: The `#undef` directive in C is used to remove the definition of a macro previously defined with `#define`, making it unavailable for use in subsequent parts of the program.

16. How are macros with parameters passed and expanded in C programming?

ⓐ. They are expanded at compile-time.

ⓑ. They are expanded at runtime.

ⓒ. They are expanded by the linker.

ⓓ. They are expanded by the preprocessor.

Correct Answer: They are expanded by the preprocessor.

Explanation: Macros with parameters defined using `#define` in C programming are expanded by the preprocessor during compilation, replacing the macro invocation with its definition.

17. Which operator is used to stringify arguments in a macro definition in C?

ⓐ. #

ⓑ. ##

ⓒ. ;

ⓓ. ::

Correct Answer: #

Explanation: The `#` operator in a macro definition in C is used for stringification, converting macro arguments into string literals during macro expansion.

18. What does a macro defined with `#define` in C programming begin with?

ⓐ.

ⓑ. &#

ⓒ. $

ⓓ. @

Correct Answer: #

Explanation: Macros defined with `#define` in C programming begin with the `#` symbol, followed by the macro name and its definition.

19. When are macros defined with `#define` in C resolved during compilation?

ⓐ. After linking

ⓑ. Before preprocessing

ⓒ. After preprocessing

ⓓ. During runtime

Correct Answer: Before preprocessing

Explanation: Macros defined with `#define` in C are resolved by the preprocessor during preprocessing, which occurs before actual compilation and linking of the program.

20. What is a potential issue with macros defined using `#define` in C programming?

ⓐ. They cannot be used with conditional statements.

ⓑ. They may cause naming conflicts.

ⓒ. They require explicit memory allocation.

ⓓ. They cannot be used with functions.

Correct Answer: They may cause naming conflicts.

Explanation: Macros defined with `#define` in C may cause naming conflicts if not carefully named, potentially leading to unintended substitutions and errors in the program.

21. What happens if a macro defined with `#define` in C programming is redefined with a different value?

ⓐ. The program fails to compile.

ⓑ. The new definition replaces the old one.

ⓒ. Both definitions are used simultaneously.

ⓓ. The compiler generates a warning.

Correct Answer: The new definition replaces the old one.

Explanation: Macros defined with `#define` in C programming can be redefined, and the new definition replaces the previous one throughout the program.

22. Which directive is used to define a macro with variable arguments in C programming?

ⓐ. #varargs

ⓑ. #define

ⓒ. #define varargs

ⓓ. #define …

Correct Answer: #define …

Explanation: The `#define …` directive in C programming is used to define macros with variable arguments, known as variadic macros, allowing flexibility in the number of arguments passed.

23. What does the `##` operator do in the context of macro definitions in C programming?

ⓐ. Concatenates macro arguments

ⓑ. Expands macros recursively

ⓒ. Converts macro arguments to strings

ⓓ. Defines a multi-line macro

Correct Answer: Concatenates macro arguments

Explanation: The `##` operator in C macro definitions is used for token concatenation, allowing multiple macro arguments to be combined into a single token during macro expansion.

24. Which statement about macro substitution with `#define` in C programming is true?

ⓐ. Macros are expanded after preprocessing.

ⓑ. Macros can only be used for numeric constants.

ⓒ. Macros with parameters cannot contain whitespace.

ⓓ. Macros can be undefined using #define.

Correct Answer: Macros are expanded after preprocessing.

Explanation: Macros defined with `#define` in C programming are expanded by the preprocessor during preprocessing, before actual compilation and linking of the program.

25. What is the primary advantage of using macros defined with `#define` in C programming?

ⓐ. They allow for runtime polymorphism.

ⓑ. They improve memory management.

ⓒ. They facilitate code portability.

ⓓ. They enable compile-time optimizations.

Correct Answer: They enable compile-time optimizations.

Explanation: Macros defined with `#define` in C programming enable compile-time optimizations by replacing repetitive code with efficient preprocessed directives.

26. Which directive is used to include a system header file in C programming?

ⓐ. #import

ⓑ. #include

ⓒ. #define

ⓓ. #pragma include

Correct Answer: #include

Explanation: The `#include` directive in C programming is used to include system and user-defined header files, allowing access to libraries and declarations necessary for the program.

27. What is a potential drawback of using macros extensively with `#define` in C programming?

ⓐ. They increase code readability.

ⓑ. They introduce subtle bugs.

ⓒ. They simplify debugging.

ⓓ. They enforce strong typing.

Correct Answer: They introduce subtle bugs.

Explanation: Extensive use of macros defined with `#define` in C programming can introduce subtle bugs due to unexpected interactions and side effects in code.

28. Which preprocessor directive is used to define constants in C programming?

ⓐ. #constant

ⓑ. #define

ⓒ. #const

ⓓ. #macro

Correct Answer: #define

Explanation: The `#define` directive in C programming is commonly used to define constants, allowing symbolic names to represent constant values throughout the program.

29. What does the `#ifndef` directive in C programming check for?

ⓐ. Checks if a macro is not defined

ⓑ. Checks if a macro is defined

ⓒ. Checks if a function is not declared

ⓓ. Checks if a variable is defined

Correct Answer: Checks if a macro is not defined

Explanation: The `#ifndef` directive in C programming checks if a specific macro has not been defined using `#define`, allowing conditional compilation based on its absence.

30. What is the scope of macros defined with `#define` in C programming?

ⓐ. Local to the file where they are defined

ⓑ. Global across all source files

ⓒ. Local to the function where they are defined

ⓓ. Limited to the header files

Correct Answer: Local to the file where they are defined

Explanation: Macros defined with `#define` in C programming are local to the file where they are defined, unless explicitly included in other files using `#include`.

31. What is the purpose of the `#include` directive in C programming?

ⓐ. To include system libraries

ⓑ. To define macros

ⓒ. To declare variables

ⓓ. To handle exceptions

Correct Answer: To include system libraries

Explanation: The `#include` directive in C programming is used to include header files or system libraries in the current source file, providing access to predefined functions and declarations.

32. Which directive is used to include a user-defined header file in C programming?

ⓐ. #import

ⓑ. #include

ⓒ. #define

ⓓ. #pragma include

Correct Answer: #include

Explanation: The `#include` directive in C programming is used to include both system and user-defined header files, facilitating modular programming and code reuse.

33. What does the `#include <stdio.h>` directive typically provide in C programming?

ⓐ. Input/output functions

ⓑ. Mathematical functions

ⓒ. String handling functions

ⓓ. Memory allocation functions

Correct Answer: Input/output functions

Explanation: The `#include <stdio.h>` directive in C programming includes the standard input/output header file, providing functions like printf(), scanf(), and file I/O operations.

34. How does the `#include “header.h”` directive differ from `#include <header.h>` in C programming?

ⓐ. They are interchangeable

ⓑ. The first searches in system directories, the second in user directories

ⓒ. The first searches in user directories, the second in system directories

ⓓ. The first is for C++ programs, the second for C programs

Correct Answer: The first searches in user directories, the second in system directories

Explanation: In C programming, `#include “header.h”` searches for header files in user-defined directories relative to the current file, while `#include <header.h>` searches in system directories.

35. Which directive is used to prevent multiple inclusions of a header file in C programming?

ⓐ. #pragma once

ⓑ. #ifndef

ⓒ. #define

ⓓ. #ifdef

Correct Answer: #ifndef

Explanation: The `#ifndef` directive in conjunction with `#define` and `#endif` is commonly used in C programming to prevent multiple inclusions of a header file, ensuring each file is included only once.

36. What is the typical extension for a header file in C programming?

ⓐ. .c

ⓑ. .h

ⓒ. .cpp

ⓓ. .txt

Correct Answer: .h

Explanation: Header files in C programming conventionally use the extension .h (e.g., header.h) to distinguish them from source files (.c) containing the actual program code.

37. What does the `#include` directive do when encountered in a C program?

ⓐ. Includes the file at compile-time

ⓑ. Executes the included file

ⓒ. Links external libraries

ⓓ. Initializes variables

Correct Answer: Includes the file at compile-time

Explanation: The `#include` directive in C programming instructs the preprocessor to include the contents of the specified file at compile-time, merging its declarations and definitions with the current file.

38. Which directive is used to include standard mathematical functions in C programming?

ⓐ. #include <stdlib.h>

ⓑ. #include <math.h>

ⓒ. #include <stdio.h>

ⓓ. #include <string.h>

Correct Answer: #include <math.h>

Explanation: The `#include <math.h>` directive in C programming includes the standard mathematical functions header file, providing functions like sin(), cos(), sqrt(), etc.

39. In C programming, how can the order of `#include` directives affect compilation?

ⓐ. It affects the program’s runtime behavior

ⓑ. It determines the order of execution

ⓒ. It affects the linking process

ⓓ. It influences symbol visibility and compatibility

Correct Answer: It influences symbol visibility and compatibility

Explanation: In C programming, the order of `#include` directives can influence symbol visibility and compatibility, especially when headers define or declare the same symbols differently.

40. What is a potential issue when using `#include` directives with large projects in C programming?

ⓐ. Increased compilation time

ⓑ. Reduced code modularity

ⓒ. Dependency on external libraries

ⓓ. Compatibility issues with IDEs

Correct Answer: Increased compilation time

Explanation: In large C projects, extensive use of `#include` directives can lead to increased compilation time due to multiple file accesses and preprocessing operations.

41. What does the `#include` directive without angle brackets or quotes (`#include filename`) typically indicate in C programming?

ⓐ. It includes a system header file

ⓑ. It includes a user-defined header file

ⓒ. It includes a standard library file

ⓓ. It includes a macro definition file

Correct Answer: It includes a user-defined header file

Explanation: In C programming, `#include filename` without angle brackets or quotes typically includes a user-defined header file located in the current or specified directory.

42. Which directive should follow `#ifndef` when preventing multiple inclusions of a header file in C programming?

ⓐ. #pragma once

ⓑ. #endif

ⓒ. #define

ⓓ. #ifdef

Correct Answer: #define

Explanation: In C programming, to prevent multiple inclusions of a header file, `#ifndef` is followed by `#define` to define a unique identifier, and then concluded with `#endif` to end the conditional block.

43. What is the purpose of using `#pragma once` in C programming?

ⓐ. To include a header file

ⓑ. To define a macro

ⓒ. To prevent multiple inclusions of a header file

ⓓ. To declare a variable

Correct Answer: To prevent multiple inclusions of a header file

Explanation: `#pragma once` in C programming is an alternative method to `#ifndef`, used to prevent multiple inclusions of a header file, ensuring it is included only once per compilation unit.

44. Which directive is used to specify the search path for header files in C programming?

ⓐ. #path

ⓑ. #define

ⓒ. #include

ⓓ. #pragma

Correct Answer: #pragma

Explanation: The `#pragma` directive in C programming can be used to specify various implementation-defined directives, but it is not typically used to specify search paths for header files.

45. What is the behavior of the `#include “header.h”` directive if the specified file is not found in the current directory in C programming?

ⓐ. It includes a system header file

ⓑ. It includes a user-defined header file from the standard library

ⓒ. It includes a user-defined header file from the specified path

ⓓ. It results in a compilation error

Correct Answer: It includes a user-defined header file from the specified path

Explanation: If the specified file is not found in the current directory, `#include “header.h”` in C programming searches in user-defined directories specified by the build environment.

46. Which directive is used to include the standard input/output functions in C programming?

ⓐ. #include <math.h>

ⓑ. #include <stdlib.h>

ⓒ. #include <stdio.h>

ⓓ. #include <string.h>

Correct Answer: #include <stdio.h>

Explanation: The `#include <stdio.h>` directive in C programming includes the standard input/output functions header file, providing functions like printf(), scanf(), and file I/O operations.

47. What is the purpose of using the `#include` directive in C programming?

ⓐ. To define variables

ⓑ. To declare functions

ⓒ. To include header files

ⓓ. To handle exceptions

Correct Answer: To include header files

Explanation: The primary purpose of the `#include` directive in C programming is to include header files, providing access to declarations, macros, and functions defined in those files.

48. What does the `#include` directive in C programming do when included inside a function?

ⓐ. Includes the file only when the function is called

ⓑ. Results in a compilation error

ⓒ. Includes the file at runtime

ⓓ. Has no effect

Correct Answer: Has no effect

Explanation: The `#include` directive in C programming is processed by the preprocessor, which operates before actual compilation begins. Including files inside functions has no effect as it operates outside the scope of function execution.

49. Which directive is used to include the standard library functions in C programming?

ⓐ. #include <math.h>

ⓑ. #include <stdlib.h>

ⓒ. #include <stdio.h>

ⓓ. #include <string.h>

Correct Answer: #include <stdlib.h>

Explanation: The `#include <stdlib.h>` directive in C programming includes the standard library header file, providing functions like malloc(), free(), and exit() for memory allocation and program termination.

50. What is a common convention for naming header files in C programming?

ⓐ. Starting with a digit

ⓑ. Using the extension .txt

ⓒ. Starting with a lowercase letter

ⓓ. Using the extension .h

Correct Answer: Using the extension .h

Explanation: In C programming, header files are conventionally named with a .h extension (e.g., header.h) to distinguish them from source files and indicate their role as header files.

51. What is the purpose of `#ifdef` in C programming?

ⓐ. Checks if a macro is defined

ⓑ. Checks if a macro is not defined

ⓒ. Includes a header file

ⓓ. Defines a macro

Correct Answer: Checks if a macro is defined

Explanation: The `#ifdef` directive in C programming checks if a specific macro has been defined using `#define`, allowing conditional compilation based on its existence.

52. Which directive is used to execute code if a macro is not defined in C programming?

ⓐ. #ifdef

ⓑ. #ifndef

ⓒ. #else

ⓓ. #endif

Correct Answer: #ifndef

Explanation: The `#ifndef` directive in C programming checks if a specific macro has not been defined using `#define`, allowing conditional execution of code when the macro is absent.

53. What does the `#if` directive in C programming evaluate?

ⓐ. Boolean expressions

ⓑ. Macro definitions

ⓒ. Variable declarations

ⓓ. Function prototypes

Correct Answer: Boolean expressions

Explanation: The `#if` directive in C programming evaluates boolean expressions, allowing conditional compilation based on the result of the expression.

54. What happens if the condition in `#if` or `#elif` directives in C programming evaluates to false?

ⓐ. The code block is skipped

ⓑ. The compiler generates an error

ⓒ. The code block is executed

ⓓ. The program enters an infinite loop

Correct Answer: The code block is skipped

Explanation: If the condition in `#if` or `#elif` directives in C programming evaluates to false, the associated code block is skipped during compilation.

55. Which directive follows `#if` or `#elif` to provide an alternative code block in C programming?

ⓐ. #else

ⓑ. #endif

ⓒ. #ifdef

ⓓ. #ifndef

Correct Answer: #else

Explanation: The `#else` directive in C programming follows `#if` or `#elif` directives to provide an alternative code block to be executed when the preceding condition is false.

56. What does the `#elif` directive in C programming stand for?

ⓐ. Else if

ⓑ. End if

ⓒ. Else include

ⓓ. End include

Correct Answer: Else if

Explanation: The `#elif` directive in C programming is short for “else if”, allowing multiple conditional branches based on different conditions within the same `#if` block.

57. Which directive ends a conditional compilation block in C programming?

ⓐ. #if

ⓑ. #else

ⓒ. #elif

ⓓ. #endif

Correct Answer: #endif

Explanation: The `#endif` directive in C programming ends a conditional compilation block started by `#if`, `#ifdef`, `#ifndef`, or `#elif`, marking the end of conditional compilation directives.

58. In C programming, what is the purpose of using conditional compilation directives like `#ifdef` and `#ifndef`?

ⓐ. To include header files

ⓑ. To define variables

ⓒ. To declare functions

ⓓ. To control compilation process

Correct Answer: To control compilation process

Explanation: Conditional compilation directives like `#ifdef` and `#ifndef` in C programming are used to selectively include or exclude portions of code based on predefined macros, controlling the compilation process.

59. Which directive is used to handle scenarios where a specific macro is not defined in C programming?

ⓐ. #else

ⓑ. #ifndef

ⓒ. #ifdef

ⓓ. #endif

Correct Answer: #ifndef

Explanation: The `#ifndef` directive in C programming is used to conditionally include code when a specific macro is not defined using `#define`.

60. What does the `#if defined(MACRO)` directive in C programming check for?

ⓐ. Checks if a macro is defined

ⓑ. Checks if a macro is not defined

ⓒ. Includes a header file

ⓓ. Defines a macro

Correct Answer: Checks if a macro is defined

Explanation: The `#if defined(MACRO)` directive in C programming checks if a specific macro has been defined using `#define`, allowing conditional compilation based on its existence.

61. Which directive in C programming is used to include a code block if a specific macro is defined?

ⓐ. #ifdef

ⓑ. #ifndef

ⓒ. #else

ⓓ. #endif

Correct Answer: #ifdef

Explanation: The `#ifdef` directive in C programming includes a code block if a specific macro has been defined using `#define`.

62. What is the purpose of `#ifndef` in C programming?

ⓐ. Checks if a macro is defined

ⓑ. Checks if a macro is not defined

ⓒ. Includes a header file

ⓓ. Defines a macro

Correct Answer: Checks if a macro is not defined

Explanation: The `#ifndef` directive in C programming checks if a specific macro has not been defined using `#define`, allowing conditional compilation based on its absence.

63. What is the effect of the `#else` directive in C programming?

ⓐ. Ends a conditional block

ⓑ. Begins a new conditional block

ⓒ. Skips to the next `#ifdef` directive

ⓓ. Provides an alternative code block

Correct Answer: Provides an alternative code block

Explanation: The `#else` directive in C programming provides an alternative code block to be executed when the preceding `#if`, `#ifdef`, or `#elif` condition is false.

64. Which directive is used to end a conditional compilation block in C programming?

ⓐ. #if

ⓑ. #else

ⓒ. #elif

ⓓ. #endif

Correct Answer: #endif

Explanation: The `#endif` directive in C programming ends a conditional compilation block started by `#if`, `#ifdef`, `#ifndef`, or `#elif`, marking the end of conditional compilation directives.

65. In C programming, how does the `#elif` directive differ from `#else`?

ⓐ. `#elif` checks a condition, `#else` provides an alternative block

ⓑ. `#elif` provides an alternative block, `#else` checks a condition

ⓒ. They are interchangeable

ⓓ. They both end a conditional block

Correct Answer: `#elif` checks a condition, `#else` provides an alternative block

Explanation: The `#elif` directive in C programming allows checking of additional conditions within the same `#if` block, whereas `#else` provides an alternative block when the preceding condition is false.

66. What is a primary use case for conditional compilation directives in C programming?

ⓐ. Enhancing code readability

ⓑ. Improving runtime performance

ⓒ. Controlling feature inclusion

ⓓ. Enforcing coding standards

Correct Answer: Controlling feature inclusion

Explanation: Conditional compilation directives in C programming are primarily used to control which sections of code are included during compilation, allowing for different configurations and feature sets.

67. Which directive allows for nested conditional compilation blocks in C programming?

ⓐ. #ifdef

ⓑ. #ifndef

ⓒ. #elif

ⓓ. #if

Correct Answer: #if

Explanation: The `#if` directive in C programming allows for nested conditional compilation blocks, facilitating complex conditional logic based on multiple macro definitions and expressions.

68. What happens if a `#endif` directive is encountered without a preceding `#if`, `#ifdef`, `#ifndef`, or `#elif` directive in C programming?

ⓐ. The compiler generates a warning

ⓑ. The program enters an infinite loop

ⓒ. The code block is skipped

ⓓ. It results in a compilation error

Correct Answer: It results in a compilation error

Explanation: In C programming, encountering a `#endif` directive without a preceding `#if`, `#ifdef`, `#ifndef`, or `#elif` directive leads to a compilation error as it lacks a corresponding conditional directive.

69. Which directive in C programming allows for conditional inclusion based on numeric expressions?

ⓐ. #ifdef

ⓑ. #ifndef

ⓒ. #if

ⓓ. #else

Correct Answer: #if

Explanation: The `#if` directive in C programming allows for conditional compilation based on numeric expressions, enabling decisions based on arithmetic and logical conditions.

70. What does the `#ifdef` directive in C programming check for?

ⓐ. Checks if a macro is defined

ⓑ. Checks if a macro is not defined

ⓒ. Includes a header file

ⓓ. Defines a macro

Correct Answer: Checks if a macro is defined

Explanation: The `#ifdef` directive in C programming checks if a specific macro has been defined using `#define`, allowing conditional compilation based on its existence.

71. Consider the following C code snippet:


#include <stdio.h>
#define DEBUG
int main() {
    #ifdef DEBUG
        printf("Debug mode is enabled.\n");
    #else
        printf("Debug mode is disabled.\n");
    #endif
    return 0;
}

What will be the output of this code?

ⓐ. Debug mode is enabled.

ⓑ. Debug mode is disabled.

ⓒ. Compilation error.

ⓓ. Undefined behavior.

Correct Answer: Debug mode is enabled.

Explanation: Since `DEBUG` macro is defined using `#define DEBUG`, the `#ifdef DEBUG` directive evaluates to true, and thus “Debug mode is enabled.” will be printed.

72. Consider the following C code snippet:


#include <stdio.h>
#define VERSION 2
int main() {
    #if VERSION == 1
        printf("Version 1 is active.\n");
    #elif VERSION == 2
        printf("Version 2 is active.\n");
    #else
        printf("Unknown version.\n");
    #endif
    return 0;
}

What will be the output of this code?

ⓐ. Version 1 is active.

ⓑ. Version 2 is active.

ⓒ. Unknown version.

ⓓ. Compilation error.

Correct Answer: Version 2 is active.

Explanation: Here, `VERSION` is defined as 2 (`#define VERSION 2`), so the `#if VERSION == 1` evaluates to false, and `#elif VERSION == 2` evaluates to true, hence “Version 2 is active.” will be printed.

73. Consider the following C code snippet:


#include <stdio.h>
#define VERBOSE 1
int main() {
    #if VERBOSE >= 2
        printf("Verbose level 2 or higher.\n");
    #elif VERBOSE == 1
        printf("Verbose level 1.\n");
    #else
        printf("Verbose level 0.\n");
    #endif 
    return 0;
}

What will be the output of this code?

ⓐ. Verbose level 2 or higher.

ⓑ. Verbose level 1.

ⓓ. Compilation error.

Correct Answer: Verbose level 1.

Explanation: `VERBOSE` is defined as 1 (`#define VERBOSE 1`), so the `#if VERBOSE >= 2` evaluates to false, and `#elif VERBOSE == 1` evaluates to true, hence “Verbose level 1.” will be printed.

74. Consider the following C code snippet:


#include <stdio.h>
#define MAX_VALUE 100
int main() {
    int value = 110;
    #ifdef MAX_VALUE
        if (value > MAX_VALUE) {
            printf("Value exceeds maximum.\n");
        } else {
            printf("Value is within limits.\n");
        }
    #endif
    return 0;
}

What will be the output of this code?

ⓐ. Value exceeds maximum.

ⓑ. Value is within limits.

ⓓ. Undefined behavior.

Correct Answer: Value exceeds maximum.

Explanation: `MAX_VALUE` is defined as 100 (`#define MAX_VALUE 100`), so the `#ifdef MAX_VALUE` directive evaluates to true, and the condition `value > MAX_VALUE` evaluates to true (`110 > 100`), hence “Value exceeds maximum.” will be printed.

75. Consider the following C code snippet:


#include <stdio.h>
#define DEBUG 1
int main() {
    #if DEBUG
        printf("Debug mode is enabled.\n");
    #else
        printf("Debug mode is disabled.\n");
    #endif
    return 0;
}

What will be the output of this code?

ⓐ. Debug mode is enabled.

ⓑ. Debug mode is disabled.

ⓓ. Undefined behavior.

Correct Answer: Debug mode is enabled.

Explanation: `DEBUG` is defined as 1 (`#define DEBUG 1`), so the `#if DEBUG` directive evaluates to true, hence “Debug mode is enabled.” will be printed.

76. Consider the following C code snippet:


#include <stdio.h>
#define PLATFORM 2
int main() {
    #if PLATFORM == 1
        printf("Platform 1 detected.\n");
    #elif PLATFORM == 2
        printf("Platform 2 detected.\n");
    #else
        printf("Unknown platform.\n");
    #endif
    return 0;
}

What will be the output of this code?

ⓐ. Platform 1 detected.

ⓑ. Platform 2 detected.

ⓓ. Compilation error.

Correct Answer: Platform 2 detected.

Explanation: `PLATFORM` is defined as 2 (`#define PLATFORM 2`), so the `#if PLATFORM == 1` evaluates to false, and `#elif PLATFORM == 2` evaluates to true, hence “Platform 2 detected.” will be printed.

77. Consider the following C code snippet:


#include <stdio.h>
#define MODE 2
int main() {
    #if MODE == 1
        printf("Mode 1 selected.\n");
    #elif MODE == 2
        printf("Mode 2 selected.\n");
    #else
        printf("Unknown mode.\n");
    #endif
    return 0;
}

What will be the output of this code?

ⓐ. Mode 1 selected.

ⓑ. Mode 2 selected.

ⓓ. Compilation error.

Correct Answer: Mode 2 selected.

Explanation: `MODE` is defined as 2 (`#define MODE 2`), so the `#if MODE == 1` evaluates to false, and `#elif MODE == 2` evaluates to true, hence “Mode 2 selected.” will be printed.

78. Consider the following C code snippet:


#include <stdio.h>
#define OPTION 3
int main() {
    #if OPTION == 1
        printf("Option 1 is chosen.\n");
    #elif OPTION == 2
        printf("Option 2 is chosen.\n");
    #else
        printf("Default option.\n");
    #endif
    return 0;
}

What will be the output of this code?

ⓐ. Option 1 is chosen.

ⓑ. Option 2 is chosen.

ⓓ. Compilation error.

Correct Answer: Default option.

Explanation: `OPTION` is defined as 3 (`#define OPTION 3`), so neither `#if OPTION == 1` nor `#elif OPTION == 2` conditions are true, hence “Default option.” will be printed.

79. Consider the following C code snippet:


#include <stdio.h>
#define FEATURE_ENABLED 1
int main() {
    #ifdef FEATURE_ENABLED
        printf("Feature is enabled.\n");
    #else
        printf("Feature is disabled.\n");
    #endif
    return 0;
}

What will be the output of this code?

ⓐ. Feature is enabled.

ⓑ. Feature is disabled.

ⓓ. Undefined behavior.

Correct Answer: Feature is enabled.

Explanation: `FEATURE_ENABLED` is defined as 1 (`#define FEATURE_ENABLED 1`), so the `#ifdef FEATURE_ENABLED` directive evaluates to true, hence “Feature is enabled.” will be printed.

80. Consider the following C code snippet:


#include <stdio.h>
#define CONFIG_OPTION 0
int main() {
    #if CONFIG_OPTION
        printf("Config option is enabled.\n");
    #else
        printf("Config option is disabled.\n");
    #endif
    return 0;
}

What will be the output of this code?

ⓐ. Config option is enabled.

ⓑ. Config option is disabled.

ⓓ. Undefined behavior.

Correct Answer: Config option is disabled.

Explanation: `CONFIG_OPTION` is defined as 0 (`#define CONFIG_OPTION 0`), so the `#if CONFIG_OPTION` directive evaluates to false, hence “Config option is disabled.” will be printed.

81. What does the `__FILE__` macro in C programming represent?

ⓐ. Current date

ⓑ. Current time

ⓓ. Current line number

Correct Answer: Current file name

Explanation: The `__FILE__` macro in C programming expands to the current file name as a string literal.

82. What does the `__LINE__` macro in C programming represent?

ⓐ. Current date

ⓑ. Current time

ⓓ. Current line number

Correct Answer: Current line number

Explanation: The `__LINE__` macro in C programming expands to the current line number as an integer.

83. What does the `__DATE__` macro in C programming represent?

ⓐ. Current date

ⓑ. Current time

ⓓ. Current line number

Correct Answer: Current date

Explanation: The `__DATE__` macro in C programming expands to the current date as a string literal in the format “MMM DD YYYY”.

84. What does the `__TIME__` macro in C programming represent?

ⓐ. Current date

ⓑ. Current time

ⓓ. Current line number

Correct Answer: Current time

Explanation: The `__TIME__` macro in C programming expands to the current time as a string literal in the format “HH:MM:SS”.

85. Consider the following C code snippet:


#include <stdio.h>
int main() {
    printf("File: %s\n", __FILE__);
    printf("Line: %d\n", __LINE__);
    printf("Date: %s\n", __DATE__);
    printf("Time: %s\n", __TIME__);
    return 0;
}

What will be the output of this code?

ⓐ. Displays current file name, line number, date, and time.

ⓑ. Compilation error.

ⓓ. Displays current file name and line number only.

Correct Answer: Displays current file name, line number, date, and time.

Explanation: This code uses predefined macros `__FILE__`, `__LINE__`, `__DATE__`, and `__TIME__` to print information about the current file, line number, date, and time.

86. Which predefined macro in C programming provides the current line number?

ⓐ. __FILE__

ⓑ. __LINE__

ⓒ. __DATE__

ⓓ. __TIME__

Correct Answer: __LINE__

Explanation: The `__LINE__` macro in C programming expands to the current line number as an integer.

87. Which predefined macro in C programming provides the current file name?

ⓐ. __FILE__

ⓑ. __LINE__

ⓒ. __DATE__

ⓓ. __TIME__

Correct Answer: __FILE__

Explanation: The `__FILE__` macro in C programming expands to the current file name as a string literal.

88. Which predefined macro in C programming provides the current date?

ⓐ. __FILE__

ⓑ. __LINE__

ⓒ. __DATE__

ⓓ. __TIME__

Correct Answer: __DATE__

Explanation: The `__DATE__` macro in C programming expands to the current date as a string literal in the format “MMM DD YYYY”.

89. Which predefined macro in C programming provides the current time?

ⓐ. __FILE__

ⓑ. __LINE__

ⓒ. __DATE__

ⓓ. __TIME__

Correct Answer: __TIME__

Explanation: The `__TIME__` macro in C programming expands to the current time as a string literal in the format “HH:MM:SS”.

90. Consider the following C code snippet:


#include <stdio.h>
#define DEBUG
int main() {
    #ifdef DEBUG
        printf("Compiled on %s at %s\n", __DATE__, __TIME__);
    #endif
    return 0;
}

What will be the output of this code?

ⓐ. Compilation error.

ⓑ. Displays current date and time.

ⓓ. Displays “DEBUG” message.

Correct Answer: Displays current date and time.

Explanation: Since `DEBUG` is defined, the `#ifdef DEBUG` directive is true, and it prints the current compilation date and time using `__DATE__` and `__TIME__` macros.

91. Consider the following C code snippet:


#include <stdio.h>
#define FUNCTION_NAME __func__
void display_info() {
    printf("Function: %s\n", FUNCTION_NAME);
    printf("File: %s\n", __FILE__);
    printf("Line: %d\n", __LINE__);
    printf("Compiled on: %s at %s\n", __DATE__, __TIME__);
}
int main() {
    display_info();
    return 0;
}

What will be the output of this code?

ⓐ. Displays function name, file name, line number, and compilation date/time.

ⓑ. Compilation error.

ⓓ. Displays function name and file name only.

Correct Answer: Displays function name, file name, line number, and compilation date/time.

Explanation: This code uses `__func__`, `__FILE__`, `__LINE__`, `__DATE__`, and `__TIME__` macros to print information about the current function, file, line number, and compilation date/time.

92. Which predefined macro in C programming provides the current function name?

ⓐ. __func__

ⓑ. __FUNCTION__

ⓓ. __func_name__

Correct Answer: __func__

Explanation: The `__func__` macro in C programming expands to the current function name as a string literal.

93. Consider the following C code snippet:


#include <stdio.h>
#define PROJECT "C_Project"
void log_message(const char *msg) {
    printf("[%s] %s (%s:%d)\n", PROJECT, msg, __FILE__, __LINE__);
}
int main() {
    log_message("Error occurred");
    return 0;
}

What will be the output of this code?

ⓐ. [C_Project] Error occurred (__FILE__:__LINE__)

ⓑ. Compilation error.

ⓓ. Displays “PROJECT” message.

Correct Answer: [C_Project] Error occurred (__FILE__:__LINE__)

Explanation: The `log_message` function uses `__FILE__` and `__LINE__` macros to print the current file name and line number where the `log_message` function is called.

94. Consider the following C code snippet:


#include <stdio.h>
#define DEBUG 1
int main() {
    #ifdef DEBUG
        printf("Debug message: Compiled on %s at %s\n", __DATE__, __TIME__);
    #else
        printf("Release message: Compiled on %s at %s\n", __DATE__, __TIME__);
    #endif
    return 0;
}

What will be the output of this code if compiled with `DEBUG` defined?

ⓐ. Debug message: Compiled on __DATE__ at __TIME__

ⓑ. Compilation error.

ⓓ. Displays “Release message” only.

Correct Answer: Debug message: Compiled on __DATE__ at __TIME__

Explanation: Since `DEBUG` is defined, the `#ifdef DEBUG` directive is true, and it prints the current compilation date and time using `__DATE__` and `__TIME__` macros.

95. Consider the following C code snippet:


#include <stdio.h>
#define LOG_INFO(message) printf("[INFO] %s (%s:%d)\n", message, __FILE__, __LINE__)
int main() {
    LOG_INFO("Application started");
    return 0;
}

What will be the output of this code?

ⓐ. [INFO] Application started (__FILE__:__LINE__)

ⓑ. Compilation error.

ⓓ. Displays “LOG_INFO” message.

Correct Answer: [INFO] Application started (__FILE__:__LINE__)

Explanation: The `LOG_INFO` macro uses `__FILE__` and `__LINE__` macros to print the current file name and line number where `LOG_INFO` is invoked, along with the message “Application started”.

96. Consider the following C code snippet:


#include <stdio.h>
#define MESSAGE "Hello, World!"
int main() {
    printf("%s\n", MESSAGE);
    printf("Compiled on %s at %s\n", __DATE__, __TIME__);
    return 0;
}

What will be the output of this code?

ⓐ. Displays “Hello, World!” and current date/time.

ⓑ. Compilation error.

ⓓ. Displays “MESSAGE” message.

Correct Answer: Displays “Hello, World!” and current date/time.

Explanation: This code prints the message “Hello, World!” defined by `MESSAGE`, and then prints the current compilation date and time using `__DATE__` and `__TIME__` macros.

97. Consider the following C code snippet:


#include <stdio.h>
#define FUNCTION_INFO printf("Function: %s (%s:%d)\n", __func__, __FILE__, __LINE__)
void display_info() {
    FUNCTION_INFO;
    printf("Compiled on: %s at %s\n", __DATE__, __TIME__);
}
int main() {
    display_info();
    return 0;
}

What will be the output of this code?

ⓐ. Displays function name, file name, line number, and compilation date/time.

ⓑ. Compilation error.

ⓓ. Displays function name and file name only.

Correct Answer: Displays function name, file name, line number, and compilation date/time.

Explanation: The `display_info` function uses `__func__`, `__FILE__`, `__LINE__`, `__DATE__`, and `__TIME__` macros to print information about the current function, file, line number, and compilation date/time.

98. Consider the following C code snippet:


#include <stdio.h>
#define LOG_ERROR(msg) fprintf(stderr, "[ERROR] %s (%s:%d)\n", msg, __FILE__, __LINE__)
int main() {
    LOG_ERROR("File not found");
    return 0;
}

What will be the output of this code?

ⓐ. [ERROR] File not found (__FILE__:__LINE__)

ⓑ. Compilation error.

ⓓ. Displays “LOG_ERROR” message.

Correct Answer: [ERROR] File not found (__FILE__:__LINE__)

Explanation: The `LOG_ERROR` macro uses `__FILE__` and `__LINE__` macros to print the current file name and line number where `LOG_ERROR` is invoked, along with the error message “File not found”.

99. Consider the following C code snippet:


#include <stdio.h>
#define DEBUG 1
int main() {
    #if DEBUG
        printf("Debugging information:\n");
        printf("Compiled on %s at %s\n", __DATE__, __TIME__);
    #else
        printf("Release information:\n");
        printf("Compiled on %s at %s\n", __DATE__, __TIME__);
    #endif 
    return 0;
}

What will be the output of this code if compiled with `DEBUG` defined?

ⓐ. Debugging information: Compiled on __DATE__ at __TIME__

ⓑ. Compilation error.

ⓓ. Displays “Release information” only.

Correct Answer: Debugging information: Compiled on __DATE__ at __TIME__

Explanation: Since `DEBUG` is defined, the `#if DEBUG` directive is true, and it prints the debugging information and current compilation date and time using `__DATE__` and `__TIME__` macros.

100. Consider the following C code snippet:


#include <stdio.h>
#define LOG_DEBUG(msg) printf("[DEBUG] %s (%s:%d)\n", msg, __FILE__, __LINE__)
int main() {
    LOG_DEBUG("Debug message");
    return 0;
}

What will be the output of this code?

ⓐ. [DEBUG] Debug message (__FILE__:__LINE__)

ⓑ. Compilation error.

ⓓ. Displays “LOG_DEBUG” message.

Correct Answer: [DEBUG] Debug message (__FILE__:__LINE__)

Explanation: The `LOG_DEBUG` macro uses `__FILE__` and `__LINE__` macros to print the current file name and line number where `LOG_DEBUG` is invoked, along with the debug message “Debug message”.

Share the above MCQs:

Click to share on Facebook (Opens in new window)
Click to share on WhatsApp (Opens in new window)
Click to share on X (Opens in new window)
Click to share on LinkedIn (Opens in new window)
Click to share on Reddit (Opens in new window)

Preprocessor Directives MCQs – Part 1

Share the above MCQs:

Related MCQs