C programming MCQs with answers and explanations

A pointer is a variable that stores the memory address of another variable. In C, pointers are declared using the * operator. Key operations include: 1) Address-of (&): Gets the memory address of a variable, 2) Dereference (*): Accesses the value at a pointer's address, 3) Pointer arithmetic: Adding/subtracting integers to pointers moves by multiples of the data type size. For example, if ptr points to an int (4 bytes), ptr+1 actually adds 4 to the address. Void pointers can point to any data type but cannot be dereferenced directly. Function pointers store addresses of functions and enable callbacks. NULL pointer has value 0 and points to nothing.

Arrays in C are contiguous memory blocks storing elements of the same type. Array name acts as a pointer to the first element, so arr[i] is equivalent to *(arr+i). Multi-dimensional arrays are stored in row-major order. Strings are character arrays terminated by '\0' (null character). The %s format specifier reads until whitespace, while %c reads a single character. Common string functions include: strcpy(), strcat(), strlen(), strcmp(), strstr(), strtok(). Important: String literals are stored in read-only memory, so modifying them causes undefined behavior. Character arrays must have space for the null terminator. fgets() is safer than gets() for string input.

A structure (struct) is a user-defined data type that groups variables of different types. Memory layout includes padding bytes for alignment optimization. The sizeof a struct may be larger than the sum of its members. Access members using dot operator (.) for structs and arrow operator (->) for struct pointers. A union is similar but all members share the same memory location - only one member can hold a value at a time. The union size is at least the size of its largest member, rounded up to its alignment requirement. Typedef creates aliases for data types, making code cleaner. Nested structures allow structures within structures. Self-referential structures (containing pointers to same type) are essential for linked lists and trees.

C provides four functions for dynamic memory: malloc() allocates uninitialized memory, calloc() allocates and zero-initializes, realloc() resizes existing allocation, and free() releases memory. These functions operate on the heap. Always check if allocation returned NULL. Memory leaks occur when allocated memory is not freed. Dangling pointers point to freed memory. Double-free errors cause undefined behavior. Wild pointers are uninitialized pointers. Buffer overflow happens when writing beyond allocated memory. Valgrind and similar tools help detect memory issues. Good practice: Set pointers to NULL after freeing.

C provides six bitwise operators: & (AND), | (OR), ^ (XOR), ~ (NOT), << (left shift), >> (right shift). Left shift by n multiplies by $2^n$. Right shift divides by $2^n$ for positive numbers (implementation-defined for negatives). Common patterns: Setting a bit (x | (1<<n)), Clearing a bit (x & ~(1<<n)), Toggling a bit (x^{1<<n}), Checking a bit (x & (1<<n)). Bit fields in structures allow compact storage. Bitwise operations are faster than arithmetic and essential for embedded programming, device drivers, and low-level hardware control.

The C preprocessor runs before compilation. #include inserts header files. #define creates macros - object-like (constants) or function-like (with parameters). Use parentheses around macro parameters to avoid precedence issues. #ifdef, #ifndef, #if, #else, #elif, #endif provide conditional compilation. #pragma gives compiler-specific instructions. Predefined macros: __FILE__, __LINE__, __DATE__, __TIME__, __func__. Header guards (#ifndef/#define/#endif) prevent multiple inclusion. The # operator converts to string, ## concatenates tokens. Macros don't have type checking and can cause multiple evaluation of arguments.