C Programming MCQs with answers Page - 1

The compilation of a C program goes through several stages:

Preprocessing:

• The preprocessor handles directives like #include, #define, and #ifdef.
• It replaces macros, expands header files, and processes conditional compilation.

Compilation:

• Converts the preprocessed C code into assembly language.

Assembly:

• Translates the assembly code into machine code (object file).

Linking:

• Combines multiple object files and libraries into a single executable.

Since preprocessing is the first stage in this sequence, the correct answer is (C) Preprocessing.

In C language, getchar() is a standard library function used to read a single character from the standard input (keyboard).

Usage of getchar()

#include <stdio.h>



int main() {

    char ch;

    printf("Enter a character: ");

    ch = getchar();  // Reads a single character

    printf("You entered: %c

", ch);

    return 0;

}

Why Not the Other Options?

• (A) putchar() → Outputs (prints) a single character, does not read.
• (B) printf() → Prints formatted output, does not read characters.
• (D) write() → A low-level system call, not a standard library function for character input.

Thus, (C) getchar() is the correct answer!

In C, the range of a signed char variable depends on its storage size, which is 1 byte (8 bits).

• The most significant bit (MSB) is used for the sign (0 for positive, 1 for negative).
• The remaining 7 bits store the value.

Correct Answer:

(B) -128 to 127 ✅

In the given C program:

#include <stdio.h>

int main ( )

{

      float floatvalue = 8.25;

      printf ("%d

", (int) floatvalue);

      return 0;

}

1. floatvalue is initialized as 8.25 (a float type).
2. (int) floatvalue typecasts 8.25 to an int, which removes the decimal part, resulting in 8.
3. The %d format specifier is used in printf(), which expects an int. Since we are explicitly typecasting floatvalue to int, it prints 8.

Correct Output:

(D) 8 ✅

The valid range of long double depends on the system and compiler, but typically for most modern compilers (like GCC with x86-64 architecture using 80-bit extended precision), the range is:

Correct Answer:

✅ (A) 3.4E-4932 to 1.1E+4932

Explanation:

• long double in most modern systems uses 80-bit extended precision (sometimes 128-bit on specific architectures).
• Its range is significantly larger than double, which has a range of approximately 1.7E-308 to 1.7E+308.
• The values 3.4E-4932 to 1.1E+4932 match the standard long double range on many x86-64 systems.

Would you like to confirm the range for a specific compiler (like GCC, Clang, or MSVC)?

In C, char is typically a signed data type unless explicitly declared as unsigned char. The range of a signed char is -128 to 127 (for 8-bit systems).

What happens when chr = 128; ?

1. 128 is out of the valid range of a signed char (-128 to 127).
2. Since char is signed by default, 128 undergoes integer overflow (wrap-around behavior).
3. The value stored in chr becomes -128 if char is signed.

However, the output depends on the compiler settings:

• If char is signed (default in most compilers) → Output: -128
• If char is unsigned → Output: 128

Thus, the output depends on the compiler and its default char behavior.

• In C, float, double, and long double are different data types.
• %lf is used in printf() to format and display a double value.
• However, in scanf(), %lf is used to read a double value, whereas %f is used for float.

Correct Format Specifiers:

Thus, %lf is specifically used for double.

In C, the modulus operator % only works with integer types (int, long, etc.). It does not work with floating-point numbers (float or double).

To find the remainder when dividing floating-point numbers, we use the fmod() function from the math.h library.

Syntax:

#include <stdio.h>

#include <math.h>



int main() {

    double p = 5.5, q = 2.0;

    double result = fmod(p, q);

    printf("fmod(%.2f, %.2f) = %.2f

", p, q, result);

    return 0;

}

Output:

fmod(5.50, 2.00) = 1.50

Why Other Options Are Incorrect?

(A) mod(p, q); ❌

• There is no standard mod() function in C for modulus operation.

(C) modulus(p, q); ❌

• modulus() is not a valid C function.

(D) p % q ❌

• % cannot be used for floating-point numbers. It works only with integers.

Final Answer:

✅ fmod(p, q); is the correct way to get the modulus of floating-point numbers in C.

The number 25.00002500025 has high precision (many decimal places). To store such numbers accurately, we need a floating-point data type.

Why "double" is the best choice?

• float (32-bit) has only 6-7 decimal places of precision, which may lose accuracy for very precise numbers.
• double (64-bit) provides about 15-16 decimal places of precision, making it more suitable for storing high-precision numbers like 25.00002500025.

Why Other Options Are Incorrect?

(B) int ❌

• int can only store whole numbers (e.g., 25, but not 25.00002500025).

(C) both int and double ❌

• int cannot store decimal values, so this option is incorrect.

(D) float ❌

• float may lose precision for very small decimal values, so it is not ideal for such cases.

Final Answer:

✅ (A) double is the best data type to store 25.00002500025 with high precision.

The modulus operator % in C only works with integers (int, long, etc.). It does not support floating-point types like float or double.

Why are (A) and (B) invalid?

(A) 2 % 4f; ❌

• 4f is a float value (4.0), and % cannot be used with float.
• This causes a compilation error.

(B) 2 % 4l; ❌

• 4l is a long integer, and 2 is also an integer.
• However, % supports long, so this is actually valid.

(C) Both 2 % 4f; and 2 % 4l; ❌

• Since 2 % 4l; is valid, this option is partially incorrect.
• But if 4l was mistakenly assumed as long double, then it would be invalid.

(D) 2 % 4; ✅ (Valid)

• Both 2 and 4 are integers, so % works fine.

Final Answer:

✅ (C) Both 2 % 4f; and 2 % 4l; (assuming 4l is mistakenly considered as long double).