Home » Programming Languages » C Programming » Miscellaneous MCQs » Part 2 » 100 Questions

Timer: Off

Random: Off

1. What is the default storage class for local variables in C programming?

ⓐ. auto

ⓑ. register

ⓒ. static

ⓓ. extern

Correct Answer: auto

Explanation: The `auto` storage class is the default for local variables in C programming. Variables declared inside functions without any storage class specifier are automatically considered `auto`.

2. In C programming, where are `auto` variables typically stored?

ⓐ. CPU registers

ⓑ. Stack memory

ⓒ. Heap memory

ⓓ. Data segment

Correct Answer: Stack memory

Explanation: `auto` variables in C programming are typically stored in the stack memory of the function where they are declared. They are allocated dynamically during runtime and deallocated when the function exits.

3. Which statement is true regarding the initialization of `auto` variables in C programming?

ⓐ. `auto` variables must be initialized at the point of declaration.

ⓑ. `auto` variables are automatically initialized to zero.

ⓒ. `auto` variables cannot be initialized with non-constant values.

ⓓ. `auto` variables are initialized with the value of the first command line argument.

Correct Answer: `auto` variables must be initialized at the point of declaration.

Explanation: `auto` variables in C programming must be initialized at the point of declaration. If not initialized explicitly, their initial value is undefined (garbage value).

4. What happens to the value of an `auto` variable after the function where it is declared exits?

ⓐ. It persists and can be accessed by other functions.

ⓑ. It is deallocated and its memory is freed.

ⓒ. It retains its value until the program exits.

ⓓ. It becomes inaccessible and its memory is marked as reserved.

Correct Answer: It is deallocated and its memory is freed.

Explanation: `auto` variables in C programming are local to the function where they are declared. They are automatically deallocated and their memory is freed when the function exits.

5. Which statement accurately describes the scope of `auto` variables in C programming?

ⓐ. Global to the file where they are declared.

ⓑ. Local to the function where they are declared.

ⓒ. Global to all functions within the file.

ⓓ. Global to the entire program.

Correct Answer: Local to the function where they are declared.

Explanation: `auto` variables in C programming have scope limited to the function where they are declared. They are not visible or accessible outside of that function.

6. In C programming, which storage class specifier is optional for declaring `auto` variables?

ⓐ. extern

ⓑ. static

ⓒ. register

ⓓ. const

Correct Answer: register

Explanation: The `register` specifier is optional for declaring `auto` variables in C programming. It indicates that the variable should be stored in CPU registers for faster access, but it does not affect the storage class as `auto` is implicit.

7. What is the primary advantage of using `auto` variables in C programming?

ⓐ. They have longer lifetime compared to other variables.

ⓑ. They can be accessed by any function in the program.

ⓒ. They are automatically initialized to zero.

ⓓ. They allow efficient use of stack memory.

Correct Answer: They allow efficient use of stack memory.

Explanation: `auto` variables in C programming allow efficient use of stack memory because they are allocated and deallocated dynamically during function execution.

8. Which statement is true regarding the linkage of `auto` variables in C programming?

ⓐ. `auto` variables have external linkage by default.

ⓑ. `auto` variables have internal linkage by default.

ⓒ. `auto` variables cannot have linkage.

ⓓ. The linkage of `auto` variables depends on their storage duration.

Correct Answer: `auto` variables cannot have linkage.

Explanation: `auto` variables in C programming do not have linkage because they are local to the function where they are declared and are not accessible outside of that function.

9. Can `auto` variables in C programming be declared with the `static` specifier?

ⓐ. Yes, to retain their value between function calls.

ⓑ. No, `static` cannot be used with `auto` variables.

ⓒ. Yes, to specify external linkage.

ⓓ. No, `auto` variables are automatically static.

Correct Answer: No, `static` cannot be used with `auto` variables.

Explanation: `static` and `auto` are mutually exclusive storage class specifiers in C programming. `static` cannot be used with `auto` variables because they have different meanings and storage durations.

10. Which of the following statements is true about the usage of `auto` variables in C programming?

ⓐ. They can be accessed by any function within the same file.

ⓑ. They must be declared at the beginning of a function.

ⓒ. They are always initialized to a default value.

ⓓ. They can be declared without any storage class specifier.

Correct Answer: They can be declared without any storage class specifier.

Explanation: `auto` variables in C programming can be declared without explicitly using the `auto` specifier because it is the default storage class for local variables.

11. What is the primary purpose of the `extern` storage class specifier in C programming?

ⓐ. To specify that a variable is local to the function where it is declared.

ⓑ. To allocate memory dynamically during runtime.

ⓒ. To specify that a variable has external linkage.

ⓓ. To optimize the access speed of variables.

Correct Answer: To specify that a variable has external linkage.

Explanation: The `extern` storage class specifier in C programming is used to declare variables that have external linkage, meaning they can be accessed across different files when properly declared.

12. Which statement accurately describes the scope of `extern` variables in C programming?

ⓐ. Global to the file where they are declared.

ⓑ. Local to the function where they are declared.

ⓒ. Global to all functions within the file.

ⓓ. Global to the entire program.

Correct Answer: Global to the file where they are declared.

Explanation: `extern` variables in C programming have scope limited to the file where they are declared. They can be accessed by other files when properly declared using `extern`.

13. What is the default initialization value of an `extern` variable in C programming if not explicitly initialized?

ⓐ. Zero

ⓑ. Garbage value

ⓒ. NULL

ⓓ. Depends on the data type

Correct Answer: Garbage value

Explanation: If not explicitly initialized, `extern` variables in C programming are initialized to garbage values because they are not automatically initialized by the compiler.

14. In C programming, where is the memory allocated for `extern` variables?

ⓐ. Heap memory

ⓑ. Stack memory

ⓒ. Data segment

ⓓ. CPU registers

Correct Answer: Data segment

Explanation: Memory for `extern` variables in C programming is allocated in the data segment of the program. This segment contains initialized and uninitialized global and static variables.

15. Which statement accurately describes the linkage of `extern` variables in C programming?

ⓐ. `extern` variables have internal linkage by default.

ⓑ. `extern` variables have no linkage.

ⓒ. `extern` variables have external linkage by default.

ⓓ. The linkage of `extern` variables depends on their storage duration.

Correct Answer: `extern` variables have external linkage by default.

Explanation: `extern` variables in C programming have external linkage by default, allowing them to be accessed across different files when properly declared using `extern`.

16. Can `extern` variables in C programming be initialized multiple times across different files?

ⓐ. Yes, but only within the same function.

ⓑ. Yes, across different functions within the same file.

ⓒ. No, `extern` variables cannot be initialized.

ⓓ. No, `extern` variables can only be initialized once.

Correct Answer: No, `extern` variables can only be initialized once.

Explanation: `extern` variables in C programming cannot be initialized multiple times across different files. They are typically declared in one file and initialized (if needed) in another file without re-declaring them.

17. Which of the following is a valid declaration of an `extern` variable in C programming?

ⓐ. extern int x = 10;

ⓑ. extern int x;

ⓒ. extern int x();

ⓓ. extern int x;

Correct Answer: extern int x;

Explanation: In C programming, `extern int x;` is a valid declaration of an `extern` variable, indicating that `x` is defined elsewhere and its memory allocation is handled in another file.

18. What happens if an `extern` variable is declared without being defined in any file?

ⓐ. It will have a compile-time error.

ⓑ. It will have a linker error.

ⓒ. It will default to a value of zero.

ⓓ. It will have an initialization error.

Correct Answer: It will have a linker error.

Explanation: If an `extern` variable is declared without being defined (allocated memory) in any file, the linker will generate an error during the linking phase because it cannot find the variable definition.

19. Which of the following statements is true about the usage of `extern` variables in C programming?

ⓐ. They must be initialized at the point of declaration.

ⓑ. They can only be accessed within the file where they are declared.

ⓒ. They cannot be used with functions.

ⓓ. They can be declared multiple times but defined only once.

Correct Answer: They can be declared multiple times but defined only once.

Explanation: `extern` variables in C programming can be declared multiple times in different files using `extern`, but they must be defined (allocated memory) only once in one of the files.

20. Which storage class specifier can `extern` variables in C programming be combined with to extend their scope across multiple files?

ⓐ. static

ⓑ. auto

ⓒ. register

ⓓ. const

Correct Answer: static

Explanation: `extern` variables in C programming can be combined with the `static` storage class specifier to extend their scope across multiple files. This combination allows the variable to have internal linkage within the file where it is declared.

21. What is the primary purpose of the `static` storage class specifier in C programming?

ⓐ. To specify that a variable has external linkage.

ⓑ. To allocate memory dynamically during runtime.

ⓒ. To retain the value of a variable between function calls.

ⓓ. To optimize the access speed of variables.

Correct Answer: To retain the value of a variable between function calls.

Explanation: The `static` storage class specifier in C programming is used to declare variables that retain their value between function calls, making them persistent throughout the program’s execution.

22. Which statement accurately describes the scope of `static` variables in C programming?

ⓐ. Global to the file where they are declared.

ⓑ. Local to the function where they are declared.

ⓒ. Global to all functions within the file.

ⓓ. Global to the entire program.

Correct Answer: Global to all functions within the file.

Explanation: `static` variables in C programming have file scope, meaning they are visible and accessible to all functions within the file where they are declared, but not outside that file.

23. What is the default initialization value of a `static` variable in C programming if not explicitly initialized?

ⓐ. Zero

ⓑ. Garbage value

ⓒ. NULL

ⓓ. Depends on the data type

Correct Answer: Zero

Explanation: If not explicitly initialized, `static` variables in C programming are automatically initialized to zero by the compiler. This ensures predictable behavior unless otherwise specified.

24. In C programming, where is the memory allocated for `static` variables?

ⓐ. Heap memory

ⓑ. Stack memory

ⓒ. Data segment

ⓓ. CPU registers

Correct Answer: Data segment

Explanation: Memory for `static` variables in C programming is allocated in the data segment of the program, alongside other global and static variables. This segment stores initialized and uninitialized static data.

25. Which statement accurately describes the linkage of `static` variables in C programming?

ⓐ. `static` variables have internal linkage by default.

ⓑ. `static` variables have external linkage by default.

ⓒ. `static` variables have no linkage.

ⓓ. The linkage of `static` variables depends on their storage duration.

Correct Answer: `static` variables have internal linkage by default.

Explanation: `static` variables in C programming have internal linkage by default, meaning they are limited to the file where they are declared and are not accessible from other files.

26. Can `static` variables in C programming be accessed outside the function where they are declared?

ⓐ. Yes, by using the `extern` specifier.

ⓑ. Yes, if they are declared with the `register` specifier.

ⓒ. No, `static` variables are local to the function.

ⓓ. No, `static` variables are automatically initialized.

Correct Answer: Yes, by using the `extern` specifier.

Explanation: `static` variables in C programming can be accessed outside the function where they are declared by using the `extern` specifier along with their declaration in another file. This provides external linkage.

27. Which of the following is a valid declaration of a `static` variable in C programming?

ⓐ. static int x = 10;

ⓑ. static int x();

ⓒ. static int x;

ⓓ. static int x = {1, 2, 3};

Correct Answer: static int x;

Explanation: In C programming, `static int x;` is a valid declaration of a `static` variable. It indicates that `x` has internal linkage and retains its value between function calls.

28. What happens if a `static` variable is declared inside a function?

ⓐ. It becomes a global variable.

ⓑ. It becomes inaccessible from other functions.

ⓒ. It retains its value between function calls.

ⓓ. It must be initialized at the point of declaration.

Correct Answer: It retains its value between function calls.

Explanation: `static` variables declared inside a function in C programming retain their value between function calls. They are initialized only once and persist throughout the program’s execution.

29. Which of the following statements is true about the usage of `static` variables in C programming?

ⓐ. They must be declared at the beginning of a function.

ⓑ. They cannot be accessed by any other function.

ⓒ. They cannot be declared inside a loop.

ⓓ. They are automatically initialized to zero.

Correct Answer: They cannot be declared inside a loop.

Explanation: `static` variables in C programming cannot be declared inside a loop because their initialization and lifetime are managed differently from variables declared inside loops, which are created and destroyed with each iteration.

30. Which storage class specifier can `static` variables in C programming be combined with to limit their scope to a single function?

ⓐ. auto

ⓑ. register

ⓒ. const

ⓓ. extern

Correct Answer: auto

Explanation: `static` variables in C programming can be combined with the `auto` storage class specifier to limit their scope to a single function. This combination ensures that the variable is local to the function and retains its value between calls.

31. What is the primary purpose of the `register` storage class specifier in C programming?

ⓐ. To specify that a variable is local to the function where it is declared.

ⓑ. To allocate memory dynamically during runtime.

ⓒ. To optimize the access speed of variables stored in CPU registers.

ⓓ. To ensure variables retain their value between function calls.

Correct Answer: To optimize the access speed of variables stored in CPU registers.

Explanation: The `register` storage class specifier in C programming is used to suggest that a variable should be stored in CPU registers for faster access, although modern compilers may ignore this suggestion.

32. Which statement accurately describes the scope of `register` variables in C programming?

ⓐ. Global to the file where they are declared.

ⓑ. Local to the function where they are declared.

ⓒ. Global to all functions within the file.

ⓓ. Global to the entire program.

Correct Answer: Local to the function where they are declared.

Explanation: `register` variables in C programming have local scope, similar to `auto` variables, and are limited to the function where they are declared. They are not accessible outside of that function.

33. What happens if a `register` variable is declared with the `static` specifier in C programming?

ⓐ. It retains its value between function calls.

ⓑ. It becomes inaccessible from other functions.

ⓒ. It must be initialized at the point of declaration.

ⓓ. It is allocated memory in the data segment.

Correct Answer: It retains its value between function calls.

Explanation: If a `register` variable is declared with the `static` specifier in C programming, it retains its value between function calls. This behavior combines the speed of register storage with the persistence of `static` variables.

34. In C programming, where is the memory allocated for `register` variables?

ⓐ. Heap memory

ⓑ. Stack memory

ⓒ. Data segment

ⓓ. CPU registers

Correct Answer: CPU registers

Explanation: `register` variables in C programming are stored in CPU registers, not in memory locations like stack, heap, or data segment. This storage class is intended for optimizing variable access speed.

35. Which statement accurately describes the linkage of `register` variables in C programming?

ⓐ. `register` variables have internal linkage by default.

ⓑ. `register` variables have external linkage by default.

ⓒ. `register` variables have no linkage.

ⓓ. The linkage of `register` variables depends on their storage duration.

Correct Answer: `register` variables have no linkage.

Explanation: `register` variables in C programming have no linkage because they are local to the function where they are declared and are stored in CPU registers for optimized access.

36. Can the address of a `register` variable be accessed in C programming?

ⓐ. Yes, using the `&` operator.

ⓑ. Yes, by using the `extern` specifier.

ⓒ. No, `register` variables have no memory address.

ⓓ. No, `register` variables cannot be used in expressions.

Correct Answer: Yes, using the `&` operator.

Explanation: Although `register` variables in C programming are stored in CPU registers and may not have a memory address in some cases, their address can still be accessed using the `&` operator to obtain the memory address.

37. Which of the following is a valid declaration of a `register` variable in C programming?

ⓐ. register int x = 10;

ⓑ. register int x();

ⓒ. register int x;

ⓓ. register int x = {1, 2, 3};

Correct Answer: register int x;

Explanation: In C programming, `register int x;` is a valid declaration of a `register` variable. It suggests that `x` should be stored in a CPU register for faster access.

38. What happens if a `register` variable is declared with the `extern` specifier in C programming?

ⓐ. It becomes accessible across multiple files.

ⓑ. It retains its value between function calls.

ⓒ. It must be initialized at the point of declaration.

ⓓ. It is allocated memory in the data segment.

Correct Answer: It becomes accessible across multiple files.

Explanation: If a `register` variable is declared with the `extern` specifier in C programming, it indicates that the variable is defined in another file and can be accessed from multiple files, extending its scope.

39. Which of the following statements is true about the usage of `register` variables in C programming?

ⓐ. They can be used with any data type.

ⓑ. They must be declared at the beginning of a function.

ⓒ. They are automatically initialized to zero.

ⓓ. They are limited to a maximum of two variables per function.

Correct Answer: They must be declared at the beginning of a function.

Explanation: `register` variables in C programming must be declared at the beginning of a function. This requirement ensures that the compiler can allocate them to CPU registers for optimized access.

40. Which storage class specifier can `register` variables in C programming be combined with to specify external linkage?

ⓐ. static

ⓑ. auto

ⓒ. const

ⓓ. extern

Correct Answer: extern

Explanation: `register` variables in C programming can be combined with the `extern` storage class specifier to specify external linkage, allowing them to be accessed across multiple files when properly declared.

41. Which bitwise operator in C is used for performing bitwise AND operation?

ⓐ.

ⓑ. &|

ⓒ. ^

ⓓ. ~

Correct Answer:

Explanation: &The bitwise AND operator in C is represented by `&` and performs bitwise AND operation between corresponding bits of two operands.

42. What is the result of the expression `5 & 3` in bitwise operations?

ⓐ. 1

ⓑ. 2

ⓒ. 3

ⓓ. 5

Correct Answer: 1

Explanation: In bitwise AND operation, `5 & 3` results in `1` because in binary, `5` is `101` and `3` is `011`, their AND gives `001`.

43. Which bitwise operator in C is used for performing bitwise OR operation?

ⓐ.

ⓑ. &|

ⓒ. ^

ⓓ. ~

Correct Answer: |

Explanation: The bitwise OR operator in C is represented by `|` and performs bitwise OR operation between corresponding bits of two operands.

44. What is the result of the expression `5 | 3` in bitwise operations?

ⓐ. 6

ⓑ. 7

ⓒ. 8

ⓓ. 9

Correct Answer: 7

Explanation: In bitwise OR operation, `5 | 3` results in `7` because in binary, `5` is `101` and `3` is `011`, their OR gives `111`.

45. Which bitwise operator in C is used for performing bitwise XOR operation?

ⓐ.

ⓑ. &|

ⓒ. ^

ⓓ. ~

Correct Answer: ^

Explanation: The bitwise XOR (exclusive OR) operator in C is represented by `^` and performs bitwise XOR operation between corresponding bits of two operands.

46. What is the result of the expression `5 ^ 3` in bitwise operations?

ⓐ. 2

ⓑ. 4

ⓒ. 6

ⓓ. 8

Correct Answer: 2

Explanation: In bitwise XOR operation, `5 ^ 3` results in `2` because in binary, `5` is `101` and `3` is `011`, their XOR gives `110`.

47. Which bitwise operator in C is used for performing bitwise NOT operation (complement)?

ⓐ.

ⓑ. &|

ⓒ. ^

ⓓ. ~

Correct Answer: ~

Explanation: The bitwise NOT (complement) operator in C is represented by `~` and performs bitwise negation (complement) of a single operand.

48. What is the result of the expression `~5` in bitwise operations?

ⓐ. -4

ⓑ. -5

ⓒ. 4

ⓓ. 5

Correct Answer: -4

Explanation: In bitwise NOT operation, `~5` results in `-6` because it negates each bit of `5` (which in binary is `101`), resulting in `-110` in two’s complement representation, which is `-6` in decimal.

49. Which bitwise operator in C is used for performing left shift operation?

ⓐ. <<

ⓑ. >>

ⓒ.

ⓓ. &|

Correct Answer: <<

Explanation: The left shift operator in C is represented by `<<` and shifts the bits of the left operand to the left by a number of positions specified by the right operand.

50. What is the result of the expression `5 << 2` in bitwise operations?

ⓐ. 10

ⓑ. 15

ⓒ. 20

ⓓ. 25

Correct Answer: 20

Explanation: In left shift operation, `5 << 2` shifts the binary representation of `5` (`101`) two positions to the left, resulting in `10100` which is `20` in decimal.

51. Which bitwise operator in C is used for performing left shift operation?

ⓐ. <<

ⓑ. >>

ⓒ.

ⓓ. &|

Correct Answer: <<

Explanation: The left shift operator in C is represented by `<<` and shifts the bits of the left operand to the left by a number of positions specified by the right operand.

52. What is the result of the expression `5 << 2` in bitwise operations?

ⓐ. 10

ⓑ. 15

ⓒ. 20

ⓓ. 25

Correct Answer: 20

Explanation: In left shift operation, `5 << 2` shifts the binary representation of `5` (`101`) two positions to the left, resulting in `10100` which is `20` in decimal.

53. What is the result of the expression `8 << 3` in bitwise operations?

ⓐ. 16

ⓑ. 32

ⓒ. 64

ⓓ. 128

Correct Answer: 64

Explanation: In left shift operation, `8 << 3` shifts the binary representation of `8` (`1000`) three positions to the left, resulting in `1000000` which is `64` in decimal.

54. Which bitwise operator in C is used for performing right shift operation?

ⓐ. <<

ⓑ. >>

ⓒ.

ⓓ. &|

Correct Answer: >>

Explanation: The right shift operator in C is represented by `>>` and shifts the bits of the left operand to the right by a number of positions specified by the right operand.

55. What is the result of the expression `16 >> 2` in bitwise operations?

ⓐ. 2

ⓑ. 4

ⓒ. 8

ⓓ. 16

Correct Answer: 4

Explanation: In right shift operation, `16 >> 2` shifts the binary representation of `16` (`10000`) two positions to the right, resulting in `100` which is `4` in decimal.

56. What is the result of the expression `-16 >> 2` in bitwise operations?

ⓐ. -2

ⓑ. -4

ⓒ. -8

ⓓ. -16

Correct Answer: -4

Explanation: In right shift operation, `-16 >> 2` shifts the binary representation of `-16` (using two’s complement) two positions to the right, resulting in `-100` which is `-4` in decimal.

57. Which bitwise operator in C is used for arithmetic right shift operation?

ⓐ. >>

ⓑ. <<

ⓒ.

ⓓ. &|

Correct Answer: >>

Explanation: The `>>` operator in C performs arithmetic right shift when used with signed integers, preserving the sign bit and shifting zeros into the most significant bits.

58. What is the result of the expression `15 >> 1` in bitwise operations?

ⓐ. 7

ⓑ. 8

ⓒ. 15

ⓓ. -15

Correct Answer: 7

Explanation: In arithmetic right shift operation, `15 >> 1` shifts the binary representation of `15` (`1111`) one position to the right, resulting in `111` which is `7` in decimal.

59. What happens if a negative number is subjected to right shift in C?

ⓐ. It remains negative.

ⓑ. It becomes positive.

ⓒ. It becomes zero.

ⓓ. It causes a runtime error.

Correct Answer: It remains negative.

Explanation: In C, right shifting a negative number (using arithmetic right shift) preserves the sign bit, so the number remains negative after shifting.

60. Which bitwise operator can be used to clear lower order bits in C programming?

ⓐ. <<

ⓑ. >>

ⓒ.

ⓓ. &|

Correct Answer:

Explanation: &The bitwise AND (`&`) operator can be used in combination with a mask to clear lower order bits in a number while preserving higher order bits.

61. What is bit masking used for in C programming?

ⓐ. Encrypting data

ⓑ. Clearing specific bits in a bit pattern

ⓒ. Performing arithmetic operations

ⓓ. Dynamic memory allocation

Correct Answer: Clearing specific bits in a bit pattern

Explanation: Bit masking in C programming involves using bitwise operators to manipulate specific bits within a bit pattern, such as clearing bits, setting bits, or checking bit values.

62. Which bitwise operator is commonly used for creating a mask in C programming?

ⓐ.

ⓑ. &|

ⓒ. ^

ⓓ. ~

Correct Answer:

Explanation: &The bitwise AND (`&`) operator is commonly used to create a mask in C programming by combining a bit pattern with another mask pattern to selectively manipulate bits.

63. What does a bitwise mask like `0xFF` represent in hexadecimal notation?

ⓐ. All bits set to 1 in the lower byte

ⓑ. All bits set to 0 in the lower byte

ⓒ. Alternate bits set to 1 and 0

ⓓ. All bits set to 1 in the upper byte

Correct Answer: All bits set to 1 in the lower byte

Explanation: In hexadecimal notation, `0xFF` represents a byte with all bits set to 1 in the lower byte, which is commonly used as a mask to select or clear specific bits.

64. How can you clear the lower 4 bits of a variable `x` in C programming using bit masking?

ⓐ. `x &= 0x0F;`

ⓑ. `x |= 0xF0;`

ⓒ. `x ^= 0xFF;`

ⓓ. `x >>= 4;`

Correct Answer: `x &= 0x0F;`

Explanation: To clear the lower 4 bits of a variable `x`, you can use the bitwise AND operator with `0x0F` (which represents `00001111` in binary), effectively masking off the lower bits.

65. Which bitwise operation can be used to set specific bits in a variable without affecting other bits?

ⓐ. Bitwise AND (&)

ⓑ. Bitwise OR (|)

ⓒ. Bitwise XOR (^)

ⓓ. Bitwise NOT (~)

Correct Answer: Bitwise OR (|)

Explanation: The bitwise OR (`|`) operator can be used to set specific bits in a variable without affecting other bits, by combining the variable with a mask where the desired bits are set to 1.

66. What is the result of the expression `x | 0x80` if `x` is `0x3F` in hexadecimal?

ⓐ. 0xBF

ⓑ. 0xCF

ⓒ. 0xFF

ⓓ. 0x7F

Correct Answer: 0xBF

Explanation: If `x` is `0x3F` (binary `00111111`), then `x | 0x80` (binary `10000000`) results in `10111111` which is `0xBF` in hexadecimal.

67. Which bitwise operator can invert all bits of a variable in C programming?

ⓐ.

ⓑ. &|

ⓒ. ^

ⓓ. ~

Correct Answer: ~

Explanation: The bitwise NOT (`~`) operator inverts all bits of a variable in C programming, turning 0s into 1s and 1s into 0s.

68. What is the result of the expression `~0x5A` if `0x5A` is `01011010` in binary?

ⓐ. 0xA5

ⓑ. 0x55

ⓒ. 0xFF

ⓓ. 0x00

Correct Answer: 0xA5

Explanation: If `0x5A` is `01011010` in binary, then `~0x5A` (inverting all bits) results in `10100101` which is `0xA5` in hexadecimal.

69. Which bitwise operator is used to check if a specific bit is set in a variable?

ⓐ.

ⓑ. &|

ⓒ. ^

ⓓ. ~

Correct Answer:

Explanation: &The bitwise AND (`&`) operator is used to check if a specific bit is set in a variable by combining the variable with a mask where only the desired bit is set to 1.

70. What is the result of the expression `x & 0x10` if `x` is `0x1A` in hexadecimal?

ⓐ. 0x00

ⓑ. 0x10

ⓒ. 0x1A

ⓓ. 0x20

Correct Answer: 0x10

Explanation: If `x` is `0x1A` (binary `00011010`), then `x & 0x10` (binary `00010000`) results in `00010000` which is `0x10` in hexadecimal.

71. Which bitwise operation can be used to set a specific bit in a variable without affecting other bits?

ⓐ. Bitwise AND (&)

ⓑ. Bitwise OR (|)

ⓒ. Bitwise XOR (^)

ⓓ. Bitwise NOT (~)

Correct Answer: Bitwise OR (|)

Explanation: The bitwise OR (`|`) operator can be used to set specific bits in a variable without affecting other bits, by combining the variable with a mask where the desired bits are set to 1.

72. What is the result of the expression `x | (1 << 3)` if `x` is `0x0F` in hexadecimal?

ⓐ. 0x17

ⓑ. 0x0F

ⓒ. 0x1F

ⓓ. 0x07

Correct Answer: 0x17

Explanation: If `x` is `0x0F` (binary `00001111`), then `1 << 3` shifts `1` three positions to the left, becoming `00001000` in binary. Thus, `x | (1 << 3)` results in `00001111 | 00001000 = 00001111` which is `0x17` in hexadecimal.

73. Which bitwise operation can be used to clear a specific bit in a variable without affecting other bits?

ⓐ. Bitwise AND (&)

ⓑ. Bitwise OR (|)

ⓓ. Bitwise NOT (~)

Correct Answer: Bitwise AND (&)

Explanation: The bitwise AND (`&`) operator can be used to clear specific bits in a variable without affecting other bits, by combining the variable with a mask where the desired bits are set to 0.

74. What is the result of the expression `x & ~(1 << 2)` if `x` is `0x1F` in hexadecimal?

ⓐ. 0x1B

ⓑ. 0x17

ⓒ. 0x07

ⓓ. 0x1F

Correct Answer: 0x1B

Explanation: If `x` is `0x1F` (binary `00011111`), then `1 << 2` shifts `1` two positions to the left, becoming `00000100` in binary. `~(1 << 2)` results in `11111011` in binary. Thus, `x & ~(1 << 2)` results in `00011111 & 11111011 = 00011011` which is `0x1B` in hexadecimal.

75. Which bitwise operation can be used to toggle a specific bit in a variable without affecting other bits?

ⓐ. Bitwise AND (&)

ⓑ. Bitwise OR (|)

ⓓ. Bitwise NOT (~)

Correct Answer: Bitwise XOR (^)

Explanation: The bitwise XOR (`^`) operator can be used to toggle specific bits in a variable without affecting other bits, by combining the variable with a mask where the desired bits are set to 1.

76. What is the result of the expression `x ^ (1 << 1)` if `x` is `0x0A` in hexadecimal?

ⓐ. 0x0B

ⓑ. 0x08

ⓒ. 0x0A

ⓓ. 0x0C

Correct Answer: 0x0B

Explanation: If `x` is `0x0A` (binary `00001010`), then `1 << 1` shifts `1` one position to the left, becoming `00000010` in binary. Thus, `x ^ (1 << 1)` results in `00001010 ^ 00000010 = 00001000` which is `0x0B` in hexadecimal.

77. Which bitwise operation can be used to check if a specific bit is set in a variable?

ⓐ. Bitwise AND (&)

ⓑ. Bitwise OR (|)

ⓓ. Bitwise NOT (~)

Correct Answer: Bitwise AND (&)

Explanation: The bitwise AND (`&`) operator can be used to check if a specific bit is set in a variable by combining the variable with a mask where only the desired bit is set to 1.

78. What is the result of the expression `x & (1 << 2)` if `x` is `0x14` in hexadecimal?

ⓐ. 0x00

ⓑ. 0x04

ⓒ. 0x14

ⓓ. 0x20

Correct Answer: 0x04

Explanation: If `x` is `0x14` (binary `00010100`), then `1 << 2` shifts `1` two positions to the left, becoming `00000100` in binary. Thus, `x & (1 << 2)` results in `00010100 & 00000100 = 00000100` which is `0x04` in hexadecimal.

79. Which bitwise operation can be used to invert all bits of a variable in C programming?

ⓐ. Bitwise AND (&)

ⓑ. Bitwise OR (|)

ⓓ. Bitwise NOT (~)

Correct Answer: Bitwise NOT (~)

Explanation: The bitwise NOT (`~`) operator inverts all bits of a variable in C programming, turning 0s into 1s and 1s into 0s.

80. What is the result of the expression `~0x5A` if `0x5A` is `01011010` in binary?

ⓐ. 0xA5

ⓑ. 0x55

ⓒ. 0xFF

ⓓ. 0x00

Correct Answer: 0xA5

Explanation: If `0x5A` is `01011010` in binary, then `~0x5A` (inverting all bits) results in `10100101` which is `0xA5` in hexadecimal.

81. What is the output of the following C code snippet?


#include <stdio.h>
int main() {
    int x = 10;
    if (x++ == 10) {
        printf("Hello, ");
    } else {
        printf("Hi, ");
    }
    printf("world!\n");
    return 0;
}

ⓐ. Hello, world!

ⓑ. Hi, world!

ⓓ. Undefined Behavior

Correct Answer: Hello, world!

Explanation: The postfix increment operator (`x++`) evaluates to the current value of `x` and then increments `x`. Therefore, `x++ == 10` evaluates to true (`10 == 10`), so “Hello, ” is printed followed by “world!”.

82. What is the output of the following C code snippet?


#include <stdio.h>
int main() {
    int x = 5;
    printf("%d\n", x++);
    printf("%d\n", ++x);
    return 0;
}

ⓐ. 5, 7

ⓑ. 5, 6

ⓒ. 6, 7

ⓓ. 6, 6

Correct Answer: 5, 6

Explanation: In the first `printf`, `x++` post-increments `x` after printing its current value (`5`). In the second `printf`, `++x` pre-increments `x` before printing its incremented value (`6`).

83. What is the output of the following C code snippet?


#include <stdio.h>
int main() {
    int x = 3;
    x += x -= x * x;
    printf("%d\n", x);
    return 0;
}

ⓐ. 3

ⓑ. 6

ⓒ. 9

ⓓ. 12

Correct Answer: 3

Explanation: The expression `x += x -= x * x;` is evaluated as `x = x + (x – (x * x));`. Substituting `x = 3`, it becomes `x = 3 + (3 – (3 * 3));` which simplifies to `x = 3 + (3 – 9);` and finally `x = 3 + (-6);` resulting in `x = 3`.

84. What is the output of the following C code snippet?


#include <stdio.h>
void func(int x) {
    if (x > 0) {
        func(--x);
        printf("%d ", x);
        func(--x);
    }
}
int main() {
    func(3);
    return 0;
}

ⓐ. 0 1 0 2 1 0

ⓑ. 0 1 2 0 1 0

ⓒ. 0 1 0 2 0 1

ⓓ. 1 0 2 0 1 0

Correct Answer: 0 1 2 0 1 0

Explanation: The function `func` is recursively called with decremented `x` values. It prints `x` when `x > 0` in the order of its calls, resulting in `0 1 2 0 1 0`.

85. What is the output of the following C code snippet?


#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;
    printf("%d ", *(ptr++));
    printf("%d ", *ptr);
    return 0;
}

ⓐ. 10 20

ⓑ. 20 30

ⓒ. 10 30

ⓓ. 20 10

Correct Answer: 10 20

Explanation: Initially, `ptr` points to `arr[0]`. `*(ptr++)` dereferences `ptr` before incrementing, printing `10`. After `ptr++`, `ptr` points to `arr[1]`, so `*ptr` prints `20`.

86. What is the output of the following C code snippet?


#include <stdio.h>
int main() {
    int a = 5, b = 10, c = 15;
    int *p[] = {&a, &b, &c};
    printf("%d ", *p[0]);
    printf("%d ", **(p + 1));
    printf("%d ", **(p + 2));
    return 0;
}

ⓐ. 5 10 15

ⓑ. 10 15 5

ⓒ. 15 10 5

ⓓ. Compilation Error

Correct Answer: 5 10 15

Explanation: `p` is an array of pointers to integers. `*p[0]` dereferences the first element of `p` (`&a`), printing `5`. `**(p + 1)` dereferences the second element (`&b`), printing `10`. `**(p + 2)` dereferences the third element (`&c`), printing `15`.

87. What is the output of the following C code snippet?


#include <stdio.h>
int main() {
    char str[] = "Hello, World!";
    char *ptr = str;
    printf("%c ", *ptr++);
    printf("%c ", *(++ptr));
    printf("%c ", *(ptr + 2));
    return 0;
}

ⓐ. H e l

ⓑ. H e o

ⓒ. e l l

ⓓ. e o l

Correct Answer: H e o

Explanation: `*ptr++` prints the character pointed by `ptr` (`H`), then increments `ptr`. `*(++ptr)` increments `ptr` first, then prints the character (`e`). `*(ptr + 2)` prints the character two positions ahead (`o`).

88. What is the output of the following C code snippet?


#include <stdio.h>
int main() {
    int i = 0;
    for (i = 0; i < 5; i++) {
        printf("%d ", i);
        continue;
        printf("Hello ");
    }
    return 0;
}

ⓐ. 0 1 2 3 4

ⓑ. 0

ⓒ. Hello

ⓓ. 0 Hello

Correct Answer: 0 1 2 3 4

Explanation: The `printf("%d ", i);` statement is executed in the loop body. `continue;` skips the remaining code in the loop body (`printf("Hello ");`) and proceeds to the next iteration.

89. What is the output of the following C code snippet?


#include <stdio.h>
int main() {
    int x = 10;
    {
        int x = 20;
        printf("%d ", x);
    }
    printf("%d ", x);
    return 0;
}

ⓐ. 10 20

ⓑ. 20 10

ⓒ. 20 20

ⓓ. Compilation Error

Correct Answer: 20 10

Explanation: Inside the inner block, `x` is `20` and is printed. Outside the block, `x` is `10` (the outer `x`), which is printed next.

90. What is the output of the following C code snippet?


#include <stdio.h>
int main() {
    int i = 1;
    printf("%d ", ++i + ++i);
    return 0;
}

ⓐ. 4

ⓑ. 5

ⓒ. 6

ⓓ. Compilation Error

Correct Answer: 6

Explanation: The expression `++i + ++i` is evaluated as `(2 + 3)`, where `++i` increments `i` to `2` and `++i` increments `i` to `3`. Thus, `2 + 3 = 5`.

91. What will be the output of the following C code snippet?


#include <stdio.h>
int main() {
    int i = 0;
    for (; i < 3; i++) {
        switch (i) {
            case 0: printf("0 ");
            case 1: printf("1 ");
            case 2: printf("2 ");
        }
    }
    return 0;
}

ⓐ. 0 1 2

ⓑ. 0 1 2 1 2 2

ⓒ. 0 1 2 1 2

ⓓ. 0 1 2 2

Correct Answer: 0 1 2 1 2

Explanation: The `switch` statement falls through each case after matching `i`. After `i = 0`, "0 " is printed. After `i = 1`, "1 " and "2 " are printed (falling through). After `i = 2`, "2 " is printed.

92. What will be the output of the following C code snippet?


#include <stdio.h>
int main() {
    int x = 5;
    printf("%d ", ++x++);
    return 0;
}

ⓐ. Compilation Error

ⓑ. 5

ⓒ. 6

ⓓ. Undefined Behavior

Correct Answer: Compilation Error

Explanation: The expression `++x++` is invalid because it attempts to increment `x` twice in the same sequence point, which is not allowed in C.

93. What will be the output of the following C code snippet?


#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30};
    int *ptr = arr;
    printf("%d ", *ptr + 2);
    printf("%d ", *(ptr + 1));
    return 0;
}

ⓐ. 12 20

ⓑ. 12 30

ⓒ. 10 20

ⓓ. Compilation Error

Correct Answer: 12 20

Explanation: `*ptr + 2` adds `2` to the value pointed by `ptr` (`10`), resulting in `12`. `*(ptr + 1)` dereferences the second element of `arr`, printing `20`.

94. What will be the output of the following C code snippet?


#include <stdio.h>
int main() {
    int x = 2;
    int y = x << 2 + 1;
    printf("%d ", y);
    return 0;
}

ⓐ. 9

ⓑ. 10

ⓒ. 12

ⓓ. Compilation Error

Correct Answer: 10

Explanation: Operator precedence makes `x << 2 + 1` equivalent to `x << (2 + 1)`, so `x << 3`. If `x` is `2`, then `2 << 3` is `16`.

95. What will be the output of the following C code snippet?


#include <stdio.h>
#define SQUARE(x) x * x
int main() {
    int y = 4 / SQUARE(2);
    printf("%d ", y);
    return 0;
}

ⓐ. 1

ⓑ. 2

ⓒ. 4

ⓓ. Compilation Error

Correct Answer: 4

Explanation: The macro `SQUARE(x)` expands to `x * x`. So, `4 / SQUARE(2)` expands to `4 / 2 * 2`, which evaluates as `(4 / 2) * 2 = 2 * 2 = 4`.

96. What will be the output of the following C code snippet?


#include <stdio.h>
int main() {
    int a[] = {1, 2, 3, 4, 5};
    int *ptr = (int*)(&a + 1);
    printf("%d ", *(ptr - 1));
    return 0;
}

ⓐ. 5

ⓑ. 4

ⓒ. 1

ⓓ. Compilation Error

Correct Answer: 5

Explanation: `&a + 1` gives the address just after the end of array `a`. Casting it to `int*` makes `ptr` point to this address. `*(ptr - 1)` then accesses the last element of `a`, which is `5`.

97. What will be the output of the following C code snippet?


#include <stdio.h>
int main() {
    int x = 5;
    x = x == 5 ? 10 : 15;
    printf("%d ", x);
    return 0;
}

ⓐ. 5

ⓑ. 10

ⓒ. 15

ⓓ. Compilation Error

Correct Answer: 10

Explanation: `x == 5 ? 10 : 15` evaluates to `10` because `x` is `5`. So, `x` is assigned `10` and printed.

98. What will be the output of the following C code snippet?


#include <stdio.h>
int main() {
    int i = 10;
    int *ptr = &i;
    printf("%d ", *ptr++);
    printf("%d ", *ptr);
    return 0;
}

ⓐ. Compilation Error

ⓑ. 10 10

ⓒ. 10 11

ⓓ. Undefined Behavior

Correct Answer: 10 10

Explanation: `*ptr++` dereferences `ptr` before incrementing it, printing `10`. After `ptr++`, `ptr` points to `i`, so `*ptr` also prints `10`.

99. What will be the output of the following C code snippet?


#include <stdio.h>
int main() {
    int x = 10;
    int *ptr = &x;
    *ptr++;
    printf("%d ", x);
    return 0;
}

ⓐ. 10

ⓑ. 11

ⓓ. Undefined Behavior

Correct Answer: 10

Explanation: `*ptr++` post-increments `ptr`, but does not affect `x` because `*ptr` is not assigned any value. So, `printf("%d ", x);` prints `10`.

100. What will be the output of the following C code snippet?


#include <stdio.h>
int main() {
    char arr[] = "Hello";
    printf("%c ", *arr++);
    printf("%s ", arr);
    return 0;
}

ⓐ. H ello

ⓑ. H ello

ⓒ. e llo

ⓓ. Compilation Error

Correct Answer: e llo

Explanation: `*arr++` prints `H`. After `arr++`, `arr` now points to `ello`. So, `printf("%s ", arr);` prints `ello`.

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)

Miscellaneous MCQs – Part 2

Share the above MCQs:

Related MCQs