C Programming Tricky MCQ

This is a tricky C feature: In C, character constants like 'a' are of type int, not char! So sizeof('a') returns the size of an int (typically 4 bytes on modern systems), not 1. This is different from C++ where character literals are of type char. Example: printf("%zu", sizeof('a')); // Output: 4 (not 1)

Tricky! According to the C standard, int main() is the correct signature. However, many compilers accept just main() (which implicitly returns int) for backward compatibility. void main() is not standard C (though some compilers allow it). The most portable is int main(void) or int main(int argc, char *argv[]).

This is a tricky C feature: In C, a[b] is equivalent to *(a + b). Therefore, 5["Hello"] is the same as "Hello"[5], which accesses the 6th character (index 5) = 'o'. The ASCII value of 'o' is 111. This works because array indexing is commutative due to pointer arithmetic.

Tricky history question: /* */ is the original C comment style. // was added in C99 (1999 standard). The # is used for preprocessor directives, not comments. In early C (K&R C), only /* */ comments existed. Some compilers might accept // in C89 mode as an extension, but it's not standard until C99.

Preprocessor directives like #include, #define, #ifdef, etc., start with # and are processed before compilation (by the preprocessor). They don't end with semicolons (except when the macro expansion includes one). Common mistake: People add semicolons after #include or #define which causes errors.

In C, an empty structure is invalid according to the standard (C99/C11). However, many compilers allow it as an extension. GCC gives it size 0, while some compilers give it size 1 (to ensure each struct has a unique address). In C++, empty structs have size 1. This is a compiler-dependent behavior, not standard C.

C identifiers must start with a letter (a-z, A-Z) or underscore (_), followed by letters, digits, or underscores. 2variable starts with a digit, so it's invalid. However, _2variable would be valid. Case matters in C identifiers (VariableName ≠ variablename).

volatile tells the compiler that the variable's value may change at any time without any action being taken by the code (e.g., by hardware, interrupts, or other threads). This prevents the compiler from optimizing away "redundant" reads or writes. It's commonly used for memory-mapped hardware registers, variables shared with interrupt service routines, or global variables in multithreaded applications.

The _Bool type was introduced in the C99 standard. Before C99, C programmers used int (0 for false, non-zero for true) or defined their own boolean types. C99 also added <stdbool.h> which defines bool, true, and false as macros. In original K&R C and ANSI C89, there was no built-in boolean type.

Tricky! Conceptually, ++i (pre-increment) increments then returns the new value, while i++ (post-increment) returns the original value then increments. However, when used as standalone statements (not in expressions), modern compilers generate identical code for both, so there's no performance difference. The difference matters only when the value is used in a larger expression.

The classic C programming book by Brian Kernighan and Dennis Ritchie is affectionately called "K&R". The first edition (1978) described the original K&R C. The second edition (1988) covered ANSI C (C89). It's known for its concise style and is considered one of the best programming books ever written. Its famous "hello, world" program introduced this tradition.

In C, integer constants starting with 0 are interpreted as octal (base 8). So 010 in octal = 8 in decimal. Similarly, 0x prefix means hexadecimal (0x10 = 16 decimal). This is a common source of bugs when people accidentally add leading zeros to decimal numbers. Example: 0123 = 1×64 + 2×8 + 3 = 83 decimal.

In C, 'a' has type int; sizeof applies to int after promotion rules for character constants.

Hosted environment requires int main() or equivalent; void main is not standard.

Pointer to const int and pointer itself const: neither target nor address changes.

Returning pointer to stack array yields dangling pointer after function returns.

Dereferencing incompatible type pointer to float storage is UB; char* and memcpy are common exceptions.

volatile does not provide atomic read-modify-write or ordering for threads.

static at file scope gives internal linkage—visible only in translation unit.

Each .c after #include expansion is one translation unit.

Signed integer overflow is undefined in C.

Common mistake uses = instead of ==; use separate assignment or explicit compare.

sizeof and dereferencing members need complete struct definition.

Hosted provides standard library; freestanding (embedded) may provide only minimal support.