C Programming - MCQ Practice Questions

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

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

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.

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}$.

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.

*p = *q assigns the value of y (20) to x through the pointer p. So x becomes 20, y remains 20.

b++ returns the current value of b (10) before incrementing, so a = 10. Then b increments to 11.

The 'long' modifier cannot be used with 'float'. You can only use 'double' or 'long double' for longer floating-point types.

Global variables are stored in the data segment (also called BSS segment for uninitialized globals). Local variables use the stack.

When 'static' is used with a global variable, it restricts its scope to the current file (internal linkage), making it not accessible from other files.

A signed char is 1 byte (8 bits) and can represent values from -128 to 127 using two's complement representation.

In C, when both operands are integers, division performs integer division, discarding the fractional part. $\frac{5}{2}$ = 2.

Strings in C are represented using double quotes and stored in character arrays. Single quotes are for single characters.

The 'volatile' keyword tells the compiler not to optimize accesses to a variable, as its value can change from external sources (hardware, signals, etc.).

'const int *ptr' makes the data constant, 'int * const ptr' makes the pointer constant, and 'const int * const ptr' makes both constant.

Using scanf("%10s", str) limits input to 10 characters, preventing buffer overflow. The gets() function is deprecated and unsafe.