C Pointers - Tricky MCQ

NULL is a macro defined as ((void*)0), representing pointer pointing to address 0. It indicates pointer doesn't point to valid memory. Dereferencing NULL causes segmentation fault. Uninitialized pointers contain garbage values, not NULL.

Pointer arithmetic automatically scales by sizeof(type). Adding 1 to int* moves 4 bytes ahead (on 32-bit). Subtracting pointers gives number of elements between them. Invalid operations: adding two pointers, multiplying/dividing pointers.

void* is generic pointer type. Must be cast to specific type before dereferencing. Pointer arithmetic not allowed because size of void is unknown. Used in generic functions like qsort(), malloc() return type.

Dangling pointer points to memory that is no longer valid (freed, out of scope, reallocated). Dereferencing causes undefined behavior - crash, garbage values, or seemingly correct results. Always set pointer to NULL after free().

Function pointer stores address of function. Syntax: return_type (*ptr_name)(parameters). Used for callbacks, function tables, strategy pattern. Must match exact signature. Calling through pointer: ptr(args) or (*ptr)(args).

++*p increments pointed value. *p++ dereferences current pointer, then pointer increments. *++p increments pointer first, then dereferences new address. Operator precedence: postfix ++ > * > prefix ++. Common source of bugs.

int **pp stores address of int* pointer. Needed when function must modify original pointer (like realloc). Used for dynamic array of pointers (2D arrays). Dereferencing: *pp gives pointer, **pp gives value.

const applies to whatever is on its left (or right if nothing on left). const int *p: can change pointer, cannot change value. int *const p: cannot change pointer, can change value. const int *const p: cannot change either.

C lacks built-in smart pointers like C++'s unique_ptr/shared_ptr. Can simulate with struct containing pointer and reference count. Requires manual implementation of RAII patterns. Still needs careful memory management.

Aliasing occurs when same memory accessed through different pointers. Compilers must assume aliasing could happen, limiting optimizations. restrict keyword (C99) promises no aliasing, enabling better optimization. Violating restrict causes undefined behavior.

Array name decays to pointer in expressions but isn't identical. Array has contiguous memory allocation. Pointer stores address, needs separate memory. Cannot assign to array name, can assign to pointer. Array knows its size (in declaring scope).

Operator precedence: [] has higher precedence than *. int *p[10] is array of pointers ([] binds first). int (*p)[10] is pointer to array (parentheses change binding). Crucial difference in declaration and usage. Common source of confusion.