C Programming - MCQ Practice Questions

In C, variable declaration requires a semicolon at the end. The syntax is 'data_type variable_name;'

x++ is post-increment. The value 5 is printed first, then x is incremented to 6.

mutable is a C++ keyword, not a C keyword. extern, volatile, and register are valid C keywords.

Following operator precedence, multiplication (*) has higher precedence than addition (+). So 3*2=6, then 5+6=11.

Both #define and const can be used to define constants in C. #define is a preprocessor directive, while const is a type qualifier.

The main() function is the entry point where program execution begins. Every C program must have a main() function.

int x = 10;

printf("%d %d", x, x++);

Why?

In the same expression, x is:

Read as x

Modified by x++

The order in which function arguments are evaluated is not specified in C. Therefore, the program has undefined behavior.

✅ Correct answer: Undefined Behavior

This is a common C interview/exam trick.

\t is the escape sequence for a tab character. \n is for newline, \s is invalid in C.

strlen() returns size_t, which is an unsigned integer type used for sizes and counts.

The * in the parameter declaration indicates that func takes a pointer to an integer, not an integer value.

Attempting to modify a const variable results in a compilation error as const variables are read-only.

Character constants in C use single quotes ('A'). Double quotes ("") are for string literals. A single character in double quotes is a string, not a character constant.

In C, the array name arr (without index) decays to a pointer to its first element, representing the base address.

This is a subtle C behavior question. Here is a clear explanation:

In C, the expression $7/2$ involves two integer literals, so integer division is performed, yielding the integer value $3$ (the fractional part is truncated).

The format specifier `%f` expects a `double` argument. However, the integer $3$ is passed instead. Strictly speaking, passing an `int` where a `double` is expected is undefined behavior according to the C standard — yet on virtually all real-world implementations (due to how `printf` is a variadic function and how arguments are passed on the stack or in registers), the integer $3$ is interpreted as a floating-point bit pattern, and the result printed is `3.000000`.

Among the given options, B) 3.0 is the closest correct answer because:

1. $7÷2=3$ (integer division, remainder discarded),

2. `%f` causes `printf` to display the value with a decimal point and six decimal places by default, so the output appears as `3.000000`, which represents $3.0$.

Option A ($3.5$) would require floating-point division (e.g., `7.$\frac{0}{2}$`), option C ($3$) would be the output of `%d`, and while D (undefined) has technical merit, the expected answer in practice is $\boxed{3.0}$.

Static variables are initialized to 0 by default. auto and register variables have garbage values if not initialized. extern variables are declared elsewhere.

The expression ++x + x++ involves modifying x multiple times without an intervening sequence point, leading to undefined behavior in C.

On a 32-bit system, the compiler inserts padding bytes so that each member is aligned to its natural alignment boundary (its own size, up to the platform's maximum).

Member-by-member layout:

Total size:

The naïve sum $1+4+8=13$ bytes is wrong because it ignores the 3 padding bytes inserted after $\text{char c}$ to ensure $\text{int x}$ starts at offset 4. No trailing padding is needed here since the struct's total size (16) is already a multiple of the largest alignment requirement (8, from $\text{double}$).

Due to floating-point precision limitations, 0.1 + 0.2 does not exactly equal 0.3 in binary representation.

The 'const' keyword creates a constant variable that cannot be modified after initialization. The compiler enforces this at compile time.

arr + 1 points to the second element. Dereferencing with * gives the value 20.