← C

Advanced Pointers

← Advanced Pointers

Select a question from the sidebar

15 questions in this topic

Question 1 / 15

What is a double pointer (pointer to pointer) and when do you use it?

A double pointer (pointer to pointer) is a variable that stores the address of another pointer. Declared with two asterisks **, it adds a second level of indirection.

Common use cases:

Modifying a pointer inside a function -- if you want a function to change where a pointer points (not just the value it points to), you pass a pointer to that pointer.
Dynamic 2D arrays -- an array of pointers, where each pointer points to a row.
Pointer arrays -- char **argv in main() is a pointer to an array of char *.

How dereferencing works:

pp is the address of the pointer
*pp is the pointer itself (the address of the final value)
**pp is the actual value

The classic interview pattern is a function that allocates memory and returns it through a parameter rather than a return value.

Pseudo Code

1. Declare pointer: int *p = &value
2. Declare double pointer: int **pp = &p
3. *pp gives you p (the pointer)
4. **pp gives you value (the pointed-to data)
5. To modify a pointer in a function, pass &p to a function accepting int **

Code

#include <stdio.h>
#include <stdlib.h>

/* Function that allocates memory and returns it via double pointer */
void allocate(int **pp, int value) {
    *pp = (int *)malloc(sizeof(int));
    if (*pp != NULL) {
        **pp = value;
    }
}

int main(void) {
    int x = 10;
    int *p = &x;
    int **pp = &p;

    printf("x   = %d\n", x);     /* 10 */
    printf("*p  = %d\n", *p);    /* 10 */
    printf("**pp = %d\n", **pp); /* 10 */

    /* Modify x through double pointer */
    **pp = 42;
    printf("x after **pp = 42: %d\n", x); /* 42 */

    /* Allocate memory through a function */
    int *dynamic = NULL;
    allocate(&dynamic, 99);
    printf("dynamic value: %d\n", *dynamic); /* 99 */
    free(dynamic);

    return 0;
}

x   = 10
*p  = 10
**pp = 10
x after **pp = 42: 42
dynamic value: 99

Key Points

•A double pointer stores the address of a pointer variable
•Dereferencing once (*pp) gives the pointer, twice (**pp) gives the value
•Essential for functions that need to modify the caller's pointer (e.g., allocate memory)
•char **argv is the most common real-world double pointer
•Each level of indirection adds one * to the declaration

Gotchas

•Forgetting to pass the address of the pointer (&p) instead of the pointer itself (p) when calling a function that expects int **
•Dereferencing a double pointer that points to a NULL pointer causes a segfault
•Memory allocated inside a function via double pointer must still be freed by the caller
•Triple pointers (int ***) are almost always a design smell -- refactor with structs instead

A double pointer (int **pp) holds the address of another pointer. Use it when a function needs to modify the caller's pointer (e.g., allocate memory and return it through a parameter). Dereference once for the pointer, twice for the value.

•int **pp stores address of a pointer; **pp accesses the final value
•Required when a function must change where the caller's pointer points

#include <stdio.h>
#include <stdlib.h>

void alloc(int **pp) {
    *pp = (int *)malloc(sizeof(int));
    **pp = 42;
}

int main(void) {
    int *p = NULL;
    alloc(&p);           /* p now points to heap memory */
    printf("%d\n", *p); /* 42 */
    free(p);
    return 0;
}

Pass &p (not p) to a function expecting int ** -- otherwise you only modify a local copy

Question 2 / 15

How do you declare and use function pointers in C?

A function pointer is a variable that stores the address of a function. The declaration syntax mirrors the function signature but wraps the pointer name in parentheses.

Declaration syntax:

return_type (*pointer_name)(param_types);

The parentheses around *pointer_name are critical -- without them, you declare a function returning a pointer instead.

Using typedef for clarity:

typedef int (*comparator)(const void *, const void *);

This creates a type alias comparator for pointers to functions matching that signature.

Calling through a function pointer: You can use either (*fp)(args) or simply fp(args) -- both are valid in C.

Assigning: Use either fp = func or fp = &func -- the function name decays to a pointer automatically.

Pseudo Code

1. Declare: return_type (*name)(param_types)
2. Assign: name = function_name  (or &function_name)
3. Call: name(args) or (*name)(args)
4. typedef return_type (*TypeName)(param_types) for cleaner code

Code

#include <stdio.h>

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

/* Using typedef for cleaner declarations */
typedef int (*operation)(int, int);

void apply(operation op, int x, int y) {
    printf("Result: %d\n", op(x, y));
}

int main(void) {
    /* Direct function pointer declaration */
    int (*fp)(int, int) = add;
    printf("%d\n", fp(3, 4));     /* 7 */
    printf("%d\n", (*fp)(3, 4));  /* 7 -- alternate call syntax */

    /* Reassign to different function */
    fp = sub;
    printf("%d\n", fp(10, 3));    /* 7 */

    /* Pass function pointer to another function */
    apply(add, 5, 2); /* Result: 7 */
    apply(sub, 5, 2); /* Result: 3 */

    return 0;
}

7
7
7
Result: 7
Result: 3

Key Points

•Syntax: return_type (*name)(param_types) -- parentheses around *name are mandatory
•Function names decay to pointers automatically: fp = func and fp = &func are equivalent
•Calling via fp(args) and (*fp)(args) are both valid
•typedef makes function pointer types far more readable
•qsort() in stdlib.h is the classic real-world function pointer example

Gotchas

•int *fp(int) declares a function returning int*, not a function pointer -- you need int (*fp)(int)
•Function pointer signature must exactly match the target function's signature
•Calling a NULL function pointer is undefined behavior (usually a crash)
•Cannot perform arithmetic on function pointers (unlike data pointers)

A function pointer stores a function's address. Syntax: int (*fp)(int, int) = add;. Call with fp(3, 4). Use typedef to simplify: typedef int (*Op)(int, int);.

•Syntax: return_type (*name)(params) -- parens around *name are essential
•Use typedef for readable function pointer types

#include <stdio.h>

int add(int a, int b) { return a + b; }

typedef int (*Op)(int, int);

int main(void) {
    Op fp = add;
    printf("%d\n", fp(3, 4)); /* 7 */
    return 0;
}

int *f(int) is a function returning int*, not a function pointer -- need int (*f)(int)

Question 3 / 15

What are callback functions in C and how do you implement the callback pattern?

A callback is a function passed as an argument to another function, which then invokes it at the appropriate time. In C, callbacks are implemented using function pointers.

The callback pattern:

Define a callback signature (usually via typedef)
Write a function that accepts a function pointer parameter
The caller provides a concrete function matching the signature
The called function invokes the callback at the right moment

Real-world examples in the C standard library:

qsort() takes a comparison callback
bsearch() takes a comparison callback
atexit() registers a cleanup callback
Signal handlers via signal()

Callbacks enable separation of concerns: the sorting algorithm does not need to know what it is sorting -- the comparison callback provides that knowledge.

Pseudo Code

1. Define callback type: typedef void (*Callback)(int)
2. Write processor function: void process(int *arr, int n, Callback cb)
3. Inside process, call cb(arr[i]) for each element
4. Caller passes a concrete function: process(arr, n, my_handler)

Code

#include <stdio.h>
#include <stdlib.h>

/* Callback type for event handling */
typedef void (*EventHandler)(const char *event);

void on_click(const char *event) {
    printf("Click handled: %s\n", event);
}

void on_hover(const char *event) {
    printf("Hover handled: %s\n", event);
}

/* Function that accepts a callback */
void register_handler(EventHandler handler, const char *event) {
    printf("Dispatching event...\n");
    handler(event); /* invoke the callback */
}

/* Classic example: qsort comparison callback */
int compare_int(const void *a, const void *b) {
    return (*(const int *)a - *(const int *)b);
}

int main(void) {
    register_handler(on_click, "button_press");
    register_handler(on_hover, "mouse_move");

    /* qsort uses a callback for comparison */
    int arr[] = {5, 2, 8, 1, 9};
    qsort(arr, 5, sizeof(int), compare_int);

    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]); /* 1 2 5 8 9 */
    }
    printf("\n");

    return 0;
}

Dispatching event...
Click handled: button_press
Dispatching event...
Hover handled: mouse_move
1 2 5 8 9

Key Points

•Callbacks are function pointers passed as arguments to other functions
•They enable decoupling: the caller decides behavior, the callee decides timing
•qsort() is the canonical C standard library callback example
•typedef makes callback signatures readable and reusable
•Callbacks often come with a void* context parameter for user data

Gotchas

•Passing a function with the wrong signature as a callback is undefined behavior
•Callbacks cannot capture local variables like closures in higher-level languages
•A common pattern is to pair a callback with a void *user_data parameter for context
•qsort comparison must return negative, zero, or positive -- not just 0 or 1

A callback is a function pointer passed as an argument. The receiving function invokes it when needed. qsort() is the classic example -- you provide a comparison function and qsort calls it to compare elements.

•Callbacks decouple the algorithm from the data-specific logic
•Always pair callbacks with a void* user_data parameter in real code

#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) {
    return *(const int *)a - *(const int *)b;
}

int main(void) {
    int arr[] = {5, 2, 8, 1};
    qsort(arr, 4, sizeof(int), cmp); /* cmp is the callback */
    for (int i = 0; i < 4; i++)
        printf("%d ", arr[i]); /* 1 2 5 8 */
    printf("\n");
    return 0;
}

1 2 5 8

Callback signature must exactly match what the caller expects -- no implicit conversions

Question 4 / 15

What is the difference between a pointer to an array and an array of pointers?

These two constructs look similar but are fundamentally different:

Pointer to an array: int (*p)[N]

p is a single pointer that points to an entire array of N integers
sizeof(*p) is N * sizeof(int)
Dereferencing: (*p)[i] accesses element i
Used with 2D arrays passed to functions: void func(int (*matrix)[COLS], int rows)

Array of pointers: int *p[N]

p is an array containing N pointer-to-int values
Each element p[i] can point to a different int or array
Common for ragged arrays (rows of different lengths)
char *argv[] is the canonical example

Precedence rule: [] binds tighter than *. So int *p[N] is an array of pointers because [] applies first. Parentheses in int (*p)[N] force * to apply first, making it a pointer to an array.

Pseudo Code

Pointer to array: int (*p)[5]
  - p points to one block of 5 ints
  - (*p)[i] accesses element i
  - p+1 advances by sizeof(int)*5 bytes

Array of pointers: int *p[5]
  - p is 5 separate int* values
  - p[i] is a pointer; *p[i] accesses the value
  - Each p[i] can point to different memory

Code

#include <stdio.h>

int main(void) {
    int arr[5] = {10, 20, 30, 40, 50};

    /* Pointer to an array of 5 ints */
    int (*ptr_to_arr)[5] = &arr;
    printf("(*ptr_to_arr)[2] = %d\n", (*ptr_to_arr)[2]); /* 30 */
    printf("sizeof(*ptr_to_arr) = %zu\n", sizeof(*ptr_to_arr)); /* 20 (5*4) */

    /* Array of 5 pointers to int */
    int a = 1, b = 2, c = 3, d = 4, e = 5;
    int *arr_of_ptrs[5] = {&a, &b, &c, &d, &e};
    printf("*arr_of_ptrs[2] = %d\n", *arr_of_ptrs[2]); /* 3 */
    printf("sizeof(arr_of_ptrs) = %zu\n", sizeof(arr_of_ptrs)); /* 40 (5*8 on 64-bit) */

    /* 2D array with pointer to array */
    int matrix[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
    int (*row)[4] = matrix; /* points to first row */
    printf("row[1][2] = %d\n", row[1][2]); /* 7 */

    return 0;
}

(*ptr_to_arr)[2] = 30
sizeof(*ptr_to_arr) = 20
*arr_of_ptrs[2] = 3
sizeof(arr_of_ptrs) = 40
row[1][2] = 7
(sizeof(arr_of_ptrs) is platform-dependent: 20 on 32-bit, 40 on 64-bit)

Key Points

•int (*p)[N] is a pointer to an array -- one pointer, points to N elements as a unit
•int *p[N] is an array of pointers -- N separate pointer variables
•[] binds tighter than * in declarations, so parentheses change the meaning
•Pointer to array is the correct type for 2D array function parameters
•Array of pointers is used for ragged arrays and argv

Gotchas

•int *p[5] vs int (*p)[5] -- forgetting parentheses completely changes the type
•Pointer arithmetic on int (*p)[N] advances by N*sizeof(int) bytes, not sizeof(int)
•Passing a 2D array to a function requires int (*param)[COLS], not int **param
•sizeof gives different results: pointer to array gives the array size, array of pointers gives N * pointer size

int (*p)[5] is a pointer to an array of 5 ints (one pointer, one block). int *p[5] is an array of 5 int pointers (five separate pointers). The [] operator binds tighter than *, so parentheses change meaning.

•int (*p)[N] -- pointer to array; int *p[N] -- array of pointers
•[] binds tighter than *, parentheses change meaning

#include <stdio.h>

int main(void) {
    int arr[5] = {10, 20, 30, 40, 50};

    int (*p1)[5] = &arr;       /* pointer to array */
    printf("%d\n", (*p1)[2]);  /* 30 */

    int a = 1, b = 2;
    int *p2[2] = {&a, &b};     /* array of pointers */
    printf("%d\n", *p2[1]);    /* 2 */

    return 0;
}

30
2

A 2D array parameter must be int (*p)[COLS], not int **p -- they are different types

Question 5 / 15

Explain all const pointer variations: const int, int const, and const int* const.

The const keyword with pointers creates three distinct variations depending on placement:

1. const int *p (pointer to const int)

The data pointed to is read-only through this pointer
The pointer itself can be reassigned to point elsewhere
Also written as int const *p (equivalent)
Use case: function parameters that promise not to modify data

2. int *const p (const pointer to int)

The pointer is fixed -- it always points to the same address
The data can be modified through the pointer
Must be initialized at declaration
Behaves like an array name (fixed address, mutable data)

3. const int *const p (const pointer to const int)

Neither the pointer nor the data can be modified
The most restrictive form
Use case: truly immutable reference to immutable data

The "clockwise/spiral" rule: Read the declaration from right to left. const applies to whatever is immediately to its left (or to its right if nothing is to its left).

Pseudo Code

const int *p      -- can change p, cannot change *p
int *const p      -- cannot change p, can change *p
const int *const p -- cannot change p, cannot change *p

Rule: read right to left
  const int *p     -> p is a pointer to int that is const
  int *const p     -> p is a const pointer to int
  const int *const p -> p is a const pointer to const int

Code

#include <stdio.h>

int main(void) {
    int x = 10, y = 20;

    /* 1. Pointer to const int: can reassign pointer, cannot modify data */
    const int *p1 = &x;
    /* *p1 = 50; */  /* ERROR: cannot modify data */
    p1 = &y;        /* OK: can reassign pointer */
    printf("p1 -> %d\n", *p1); /* 20 */

    /* 2. Const pointer to int: cannot reassign pointer, can modify data */
    int *const p2 = &x;
    *p2 = 50;       /* OK: can modify data */
    /* p2 = &y; */  /* ERROR: cannot reassign pointer */
    printf("x = %d\n", x); /* 50 */

    /* 3. Const pointer to const int: cannot do either */
    const int *const p3 = &x;
    /* *p3 = 99; */  /* ERROR: cannot modify data */
    /* p3 = &y; */   /* ERROR: cannot reassign pointer */
    printf("p3 -> %d\n", *p3); /* 50 */

    /* Practical use: function that promises not to modify data */
    /* void print_array(const int *arr, int n); */

    return 0;
}

p1 -> 20
x = 50
p3 -> 50

Key Points

•const int *p -- data is read-only, pointer can change (most common in APIs)
•int *const p -- pointer is fixed, data is writable (like an array name)
•const int *const p -- both are immutable
•const int * and int const * are identical (const binds leftward)
•Use const int * for function parameters to signal no modification

Gotchas

•Casting away const and then modifying is undefined behavior if the original was truly const
•const int *p does NOT mean the underlying data is immutable -- only that you cannot modify it through p
•Forgetting const in function parameters prevents passing const arrays to the function
•int const * and const int * are the same, but int *const is different -- position of const relative to * matters

const int *p -- data is read-only, pointer reassignable. int *const p -- pointer is fixed, data writable. const int *const p -- both locked. Read right-to-left: const applies to what is on its left.

•const before * protects data; const after * protects the pointer
•const int * is the most common -- used in function parameters

#include <stdio.h>

int main(void) {
    int x = 10, y = 20;
    const int *p1 = &x;       /* can't modify *p1, can reassign p1 */
    int *const p2 = &x;       /* can modify *p2, can't reassign p2 */
    const int *const p3 = &x; /* can't do either */

    p1 = &y;  /* OK */
    *p2 = 50; /* OK */
    printf("%d %d %d\n", *p1, *p2, *p3); /* 20 50 50 */
    return 0;
}

20 50 50

Casting away const and modifying is undefined behavior

Question 6 / 15

How do you declare a pointer to a function that returns a pointer?

This is a common interview question testing your ability to read complex C declarations.

A pointer to a function returning int*:

int *(*fp)(int, int);

Breaking it down:

(*fp) -- fp is a pointer
(*fp)(int, int) -- to a function taking two ints
int *(*fp)(int, int) -- that returns int*

Without the inner parentheses:

int **fp(int, int);

This declares a function (not a pointer) that returns int **.

Using typedef for clarity:

typedef int *(*FuncPtr)(int, int);
FuncPtr fp = my_function;

Even more complex -- a function returning a function pointer:

int (*(*fp)(int))(double);

fp is a pointer to a function taking int, returning a pointer to a function taking double and returning int.

Always use typedef for anything beyond one level of function pointer nesting.

Pseudo Code

1. Start with the variable name: fp
2. Add pointer: (*fp)
3. Add function parameters: (*fp)(int, int)
4. Add return type: int *(*fp)(int, int)

With typedef:
  typedef int *(*FuncPtr)(int, int);
  FuncPtr fp = my_function;

Code

#include <stdio.h>
#include <stdlib.h>

/* A function that returns a pointer to int */
int *find_max(int *a, int *b) {
    return (*a > *b) ? a : b;
}

int *create_int(int value) {
    int *p = (int *)malloc(sizeof(int));
    if (p) *p = value;
    return p;
}

int main(void) {
    int x = 10, y = 20;

    /* Pointer to function returning int* */
    int *(*fp)(int *, int *) = find_max;
    int *result = fp(&x, &y);
    printf("max = %d\n", *result); /* 20 */

    /* Using typedef */
    typedef int *(*Creator)(int);
    Creator make = create_int;
    int *p = make(42);
    printf("created = %d\n", *p); /* 42 */
    free(p);

    return 0;
}

max = 20
created = 42

Key Points

•int *(*fp)(params) -- pointer to function returning int*
•int **fp(params) -- function (not pointer) returning int** -- completely different
•The inner parentheses around *fp are what make it a pointer to a function
•Always use typedef for complex function pointer types
•signal() from <signal.h> is a real-world example of a function returning a function pointer

Gotchas

•Missing the inner parentheses changes the meaning entirely
•signal() has one of the most confusing declarations in C -- always use typedef
•Memory returned by such functions may need to be freed by the caller
•Read complex declarations inside-out, not left-to-right

int *(*fp)(int, int) is a pointer to a function returning int*. The parentheses around *fp are essential. Without them, int **fp(int, int) is a function returning int**. Use typedef for readability.

•int *(*fp)(params) -- pointer to function returning int*
•Use typedef to avoid declaration confusion

#include <stdio.h>

int *bigger(int *a, int *b) {
    return (*a > *b) ? a : b;
}

int main(void) {
    int x = 5, y = 9;
    int *(*fp)(int *, int *) = bigger;
    printf("%d\n", *fp(&x, &y)); /* 9 */
    return 0;
}

Without parentheses around *fp, it becomes a function declaration, not a function pointer

Question 7 / 15

What are the rules for void pointer arithmetic in C?

Standard C (C99/C11): Arithmetic on void * is not allowed. The standard requires the compiler to know the pointed-to type's size to perform pointer arithmetic, and void has no size.

GCC extension: GCC (and Clang in GCC-compatibility mode) allows arithmetic on void * by treating it as if sizeof(void) == 1 (byte-level arithmetic). This is a non-standard extension enabled by default.

The standard-compliant approach: Cast to char * before performing arithmetic, then cast back:

void *ptr = some_address;
void *next = (char *)ptr + offset_in_bytes;

Why this matters:

void * is used extensively in generic functions (malloc, memcpy, qsort)
Writing portable code requires casting to char * for byte arithmetic
Compiling with -pedantic or MSVC will reject void pointer arithmetic

Pseudo Code

Standard C:
  void *p = ...;
  p + 1;  /* ILLEGAL -- compiler error with -pedantic */
  ((char *)p) + 1;  /* LEGAL -- advances by 1 byte */

GCC extension:
  void *p = ...;
  p + 1;  /* Allowed by GCC, treated as +1 byte */

Portable pattern:
  void *advance(void *ptr, size_t elem_size, size_t index) {
      return (char *)ptr + (elem_size * index);
  }

Code

#include <stdio.h>
#include <string.h>

/* Portable generic element access using char* arithmetic */
void *generic_element(void *base, size_t elem_size, size_t index) {
    return (char *)base + (elem_size * index);
}

void generic_swap(void *a, void *b, size_t size) {
    char temp[size]; /* VLA -- C99 */
    memcpy(temp, a, size);
    memcpy(a, b, size);
    memcpy(b, temp, size);
}

int main(void) {
    int arr[] = {10, 20, 30, 40, 50};

    /* Portable: cast to char* for byte-level arithmetic */
    void *base = arr;
    int *third = (int *)((char *)base + 2 * sizeof(int));
    printf("third element: %d\n", *third); /* 30 */

    /* Using our generic function */
    int *elem = (int *)generic_element(arr, sizeof(int), 3);
    printf("fourth element: %d\n", *elem); /* 40 */

    /* Generic swap */
    int x = 5, y = 10;
    generic_swap(&x, &y, sizeof(int));
    printf("x=%d y=%d\n", x, y); /* x=10 y=5 */

    return 0;
}

third element: 30
fourth element: 40
x=10 y=5

Key Points

•Standard C forbids arithmetic on void* -- the compiler does not know the element size
•GCC/Clang allow it as an extension, treating sizeof(void) as 1
•Portable code casts to char* for byte-level arithmetic, then casts back
•memcpy and memmove work with void* because they take a size parameter
•Always use -pedantic flag to catch non-portable void pointer arithmetic

Gotchas

•Code using void pointer arithmetic compiles with GCC but fails with MSVC or strict mode
•You cannot dereference a void pointer -- must cast to a concrete type first
•sizeof(void) is 1 in GCC but undefined in standard C
•Alignment issues can arise when casting void* to stricter types

Standard C forbids void * arithmetic (unknown element size). GCC allows it as an extension (treats sizeof(void) as 1). For portable code, cast to char * first: (char *)vp + offset.

•Standard C: no void* arithmetic; cast to char* first
•GCC extension allows it but code becomes non-portable

#include <stdio.h>

int main(void) {
    int arr[] = {10, 20, 30};
    void *vp = arr;

    /* Portable: cast to char* for byte arithmetic */
    int *p = (int *)((char *)vp + sizeof(int));
    printf("%d\n", *p); /* 20 */
    return 0;
}

Compiling with -pedantic will warn about void pointer arithmetic even on GCC

Question 8 / 15

What are near and far pointers in C, and are they still relevant?

Near and far pointers are a historical concept from the 16-bit x86 segmented memory model (MS-DOS era, Intel 8086/80286).

Near pointer:

Stores only a 16-bit offset within the current segment
2 bytes, faster access
Limited to 64 KB (one segment)

Far pointer:

Stores both a 16-bit segment and a 16-bit offset (segment:offset)
4 bytes, can address up to 1 MB of memory
Slower due to segment register loading

Huge pointer:

Like far but normalized so that two huge pointers to the same address will be equal
Far pointers can have different segment:offset pairs that map to the same physical address

Modern relevance:

On modern 32/64-bit flat memory model systems, all pointers are effectively "near" (flat address space)
The keywords near, far, huge are not part of standard C -- they were compiler extensions (Turbo C, Borland, early Microsoft C)
Still relevant in embedded systems with segmented architectures (some microcontrollers, DSPs)
Understanding them is important for legacy code maintenance and interview knowledge

Pseudo Code

16-bit segmented model:
  Physical address = (segment << 4) + offset

Near pointer: 16-bit offset only
  Range: 0 to 65535 within current segment

Far pointer: segment:offset pair
  Range: 0 to 1MB (20-bit address space)
  Example: 0x1234:0x5678 -> physical 0x179B8

Modern (32/64-bit): flat address space
  All pointers use full address, no segments
  near/far distinction does not apply

Code

#include <stdio.h>

/*
 * Near/far pointers are NOT standard C.
 * They were extensions in DOS-era compilers.
 *
 * Turbo C / Borland C syntax (historical, will not compile on modern systems):
 *   int near *np;    -- 16-bit offset only
 *   int far *fp;     -- segment:offset
 *   int huge *hp;    -- normalized far pointer
 *
 * Modern equivalent: all pointers are flat addresses.
 */

int main(void) {
    int x = 42;
    int *p = &x; /* On modern systems, this is a flat address */

    printf("sizeof(int *) = %zu bytes\n", sizeof(int *));
    /* 4 on 32-bit, 8 on 64-bit -- flat address space */

    printf("Pointer value: %p\n", (void *)p);
    printf("Value: %d\n", *p);

    /*
     * On a hypothetical segmented system:
     * int far *fp = (int far *)MK_FP(segment, offset);
     * Physical addr = (segment << 4) + offset
     *
     * Far pointer gotcha:
     * 0x1000:0x0010 and 0x1001:0x0000 both map to
     * physical address 0x10010, but far pointer ==
     * comparison would say they are different.
     * Huge pointers normalize to fix this.
     */

    return 0;
}

Key Points

•Near pointers: 16-bit offset within one 64KB segment (fast, limited range)
•Far pointers: segment:offset pair addressing up to 1MB (slower, wider range)
•Huge pointers: normalized far pointers that compare correctly
•Not part of standard C -- they were DOS-era compiler extensions
•Modern 32/64-bit systems use flat addressing; all pointers are equivalent to 'near'

Gotchas

•Two far pointers with different segment:offset values can point to the same physical address
•near/far/huge keywords will not compile on modern standard C compilers
•Some embedded systems still use segmented memory models where this distinction matters
•Interview question is testing historical knowledge -- clarify that it is not relevant on modern desktop/server systems

Near pointers (16-bit offset, 64KB range) and far pointers (segment:offset, 1MB range) are from the 16-bit x86 segmented memory era. Not standard C -- they were compiler extensions. Modern systems use flat addressing; all pointers are effectively the same.

•Historical DOS concept: near (2 bytes), far (4 bytes), huge (normalized far)
•Not standard C; modern systems use flat addressing

#include <stdio.h>

int main(void) {
    /* Modern systems: all pointers are flat addresses */
    int x = 42;
    int *p = &x;
    printf("sizeof(int *) = %zu\n", sizeof(int *)); /* 4 or 8 */
    printf("address: %p, value: %d\n", (void *)p, *p);

    /* Historical DOS:
     * int near *np;  -- 16-bit offset
     * int far *fp;   -- segment:offset (4 bytes)
     * int huge *hp;  -- normalized far pointer
     */
    return 0;
}

Two different far pointers can map to the same physical address -- huge pointers fix this

Question 9 / 15

What are opaque pointers and how do they enable data hiding in C?

An opaque pointer is a pointer to a struct whose definition is hidden from the user. The header file declares the struct name (forward declaration) but does not reveal its members. Only the implementation file (.c) has the full definition.

This is C's primary mechanism for encapsulation and information hiding, mimicking private members in OOP languages.

The pattern:

Header (.h): Forward-declare the struct and provide function prototypes
Implementation (.c): Define the struct and implement the functions
Client code: Can only use the pointer through the API functions

Benefits:

Users cannot access internal fields (compile-time enforcement)
Internal representation can change without breaking the API
Reduces compilation dependencies (changes to the struct do not force recompilation of client code)

Real-world examples:

FILE * from <stdio.h> is an opaque pointer
DIR * from <dirent.h>
sqlite3 * in SQLite
Many OS handles (Windows HANDLE)

Pseudo Code

Header (stack.h):
  typedef struct Stack Stack;   /* forward declaration only */
  Stack *stack_create(void);
  void stack_push(Stack *s, int value);
  int stack_pop(Stack *s);
  void stack_destroy(Stack *s);

Implementation (stack.c):
  struct Stack {               /* full definition hidden here */
      int *data;
      int top;
      int capacity;
  };
  /* implement all functions */

Client:
  Stack *s = stack_create();   /* cannot access s->data */
  stack_push(s, 42);           /* must use API */

Code

/* === stack.h (header -- public API) === */
#ifndef STACK_H
#define STACK_H

/* Opaque type: clients see only a pointer, not the internals */
typedef struct Stack Stack;

Stack *stack_create(int capacity);
void stack_push(Stack *s, int value);
int stack_pop(Stack *s);
int stack_is_empty(const Stack *s);
void stack_destroy(Stack *s);

#endif

/* === stack.c (implementation -- struct defined here) === */
/* #include "stack.h" */
#include <stdio.h>
#include <stdlib.h>

struct Stack {
    int *data;
    int top;
    int capacity;
};

Stack *stack_create(int capacity) {
    Stack *s = (Stack *)malloc(sizeof(Stack));
    if (!s) return NULL;
    s->data = (int *)malloc(sizeof(int) * capacity);
    s->top = -1;
    s->capacity = capacity;
    return s;
}

void stack_push(Stack *s, int value) {
    if (s->top < s->capacity - 1) {
        s->data[++s->top] = value;
    }
}

int stack_pop(Stack *s) {
    if (s->top >= 0) return s->data[s->top--];
    return -1; /* error value */
}

int stack_is_empty(const Stack *s) {
    return s->top == -1;
}

void stack_destroy(Stack *s) {
    if (s) {
        free(s->data);
        free(s);
    }
}

/* === main.c (client code) === */
int main(void) {
    Stack *s = stack_create(10);
    stack_push(s, 10);
    stack_push(s, 20);
    stack_push(s, 30);

    while (!stack_is_empty(s)) {
        printf("%d ", stack_pop(s)); /* 30 20 10 */
    }
    printf("\n");

    /* s->data = NULL; */  /* ERROR: struct Stack is incomplete */
    stack_destroy(s);
    return 0;
}

30 20 10

Key Points

•Forward-declare the struct in the header; define it only in the .c file
•Clients can only hold pointers, never stack-allocate or access members
•FILE * is the most well-known opaque pointer in C
•Enables ABI stability -- internal changes do not break client code
•All allocation/deallocation must go through API functions (constructor/destructor pattern)

Gotchas

•Clients cannot use sizeof() on the opaque type -- must heap-allocate through the API
•Forgetting to provide a destroy/free function causes memory leaks since clients cannot free internals
•If the struct definition leaks into the header, encapsulation is broken
•Every operation requires a function call -- no direct member access, slight performance cost

An opaque pointer is a pointer to a forward-declared struct whose members are hidden from clients. The struct is defined only in the .c file. Clients must use API functions to interact with it. FILE * is the classic example.

•Forward declare struct in header, define in .c file only
•FILE * is the canonical opaque pointer in C

/* header: */
typedef struct Widget Widget; /* forward declaration only */
Widget *widget_create(void);
void widget_set_value(Widget *w, int val);
void widget_destroy(Widget *w);

/* source file: */
#include <stdlib.h>
struct Widget { int value; }; /* hidden from clients */

Widget *widget_create(void) {
    return (Widget *)calloc(1, sizeof(Widget));
}
void widget_set_value(Widget *w, int val) { w->value = val; }
void widget_destroy(Widget *w) { free(w); }

/* client: w->value is inaccessible */

Clients cannot stack-allocate or sizeof() an opaque type -- must use create/destroy API

Question 10 / 15

What does the restrict keyword do in C?

The restrict keyword (C99) is a type qualifier for pointers. It tells the compiler that the pointer is the only way to access the memory it points to during its lifetime. No other pointer will alias (point to) the same memory.

This is a promise from the programmer to the compiler, enabling aggressive optimizations:

The compiler can keep values in registers instead of re-reading from memory
Loop iterations can be reordered or vectorized
Writes through one pointer do not invalidate reads through another

Standard library usage: memcpy has restrict parameters (no overlap allowed), while memmove does not (overlap is safe):

void *memcpy(void *restrict dest, const void *restrict src, size_t n);
void *memmove(void *dest, const void *src, size_t n);

If the promise is broken (aliasing occurs), behavior is undefined.

Note: restrict exists only in C (C99+), not in C++. Some compilers offer __restrict or __restrict__ as extensions in C++.

Pseudo Code

Without restrict:
  void add(int *a, int *b, int *out, int n)
  Compiler must reload *a and *b after every write to *out
  because a, b, out might alias

With restrict:
  void add(int *restrict a, int *restrict b, int *restrict out, int n)
  Compiler knows a, b, out point to separate memory
  Can vectorize and keep values in registers

Code

#include <stdio.h>
#include <string.h>

/*
 * With restrict, the compiler can optimize this loop
 * because it knows a, b, and result do not overlap.
 */
void vector_add(int *restrict result,
                const int *restrict a,
                const int *restrict b,
                int n) {
    for (int i = 0; i < n; i++) {
        result[i] = a[i] + b[i];
    }
}

/*
 * Without restrict, the compiler must be conservative:
 * writing to out[i] could change a[i] or b[i].
 */
void vector_add_no_restrict(int *out, const int *a, const int *b, int n) {
    for (int i = 0; i < n; i++) {
        out[i] = a[i] + b[i];
    }
}

int main(void) {
    int a[] = {1, 2, 3, 4};
    int b[] = {10, 20, 30, 40};
    int result[4];

    vector_add(result, a, b, 4);
    for (int i = 0; i < 4; i++) {
        printf("%d ", result[i]); /* 11 22 33 44 */
    }
    printf("\n");

    /* memcpy uses restrict: source and dest must not overlap */
    char src[] = "Hello";
    char dst[6];
    memcpy(dst, src, 6); /* OK: different buffers */
    printf("%s\n", dst); /* Hello */

    /* For overlapping memory, use memmove (no restrict) */
    char buf[] = "Hello World";
    memmove(buf + 2, buf, 5); /* OK: overlap handled */
    printf("%s\n", buf); /* HeHello orld */

    return 0;
}

11 22 33 44
Hello
HeHello orld

Key Points

•restrict tells the compiler this pointer is the only way to access its memory
•Enables optimizations: register caching, loop vectorization, instruction reordering
•It is a promise from the programmer -- violating it is undefined behavior
•memcpy uses restrict (no overlap); memmove does not (overlap allowed)
•C99 feature; not available in C++ (use __restrict as compiler extension)

Gotchas

•Breaking the restrict contract (aliasing) causes undefined behavior -- not a compile error
•restrict only applies to pointers, not to the data itself
•Compilers cannot verify restrict at compile time -- it is entirely the programmer's responsibility
•Not part of C++ -- use __restrict__ (GCC/Clang) or __restrict (MSVC) as non-portable extensions

restrict (C99) tells the compiler that a pointer is the sole accessor of its memory, enabling optimizations. Violating this promise is undefined behavior. memcpy uses restrict (no overlap); memmove does not.

•Promises no aliasing, enabling compiler optimizations
•C99 only -- not part of C++

#include <stdio.h>

/* restrict allows the compiler to optimize aggressively */
void add(int *restrict out, const int *restrict a,
         const int *restrict b, int n) {
    for (int i = 0; i < n; i++)
        out[i] = a[i] + b[i];
}

int main(void) {
    int a[] = {1, 2}, b[] = {3, 4}, r[2];
    add(r, a, b, 2);
    printf("%d %d\n", r[0], r[1]); /* 4 6 */
    return 0;
}

4 6

Breaking the restrict promise is undefined behavior, not a compile error

Question 11 / 15

What is pointer aliasing and why does it matter for optimization?

Pointer aliasing occurs when two or more pointers refer to the same memory location. This is a critical concern for compiler optimizations.

Why aliasing matters: When the compiler sees a write through one pointer, it must assume that any other pointer could be pointing to the same location and therefore reload values. This prevents many optimizations.

The strict aliasing rule (C99, section 6.5): An object shall have its stored value accessed only through an lvalue of:

A compatible type
A qualified version of a compatible type
A signed/unsigned version of a compatible type
A type that includes the above as a member (struct/union)
A char type (char can alias anything)

Accessing memory through an incompatible pointer type (e.g., casting int * to float * and dereferencing) is undefined behavior under strict aliasing.

GCC flag: -fstrict-aliasing is enabled by default at -O2 and above. Use -fno-strict-aliasing to disable or -Wstrict-aliasing for warnings.

Pseudo Code

Aliasing problem:
  void foo(int *a, int *b) {
      *a = 10;
      *b = 20;     /* compiler cannot assume a != b */
      return *a;   /* must reload *a (might be 20 if a == b) */
  }

Strict aliasing rule:
  int x = 42;
  float *fp = (float *)&x;
  float f = *fp;  /* UNDEFINED BEHAVIOR: int accessed as float */

Safe exception: char can alias anything
  char *cp = (char *)&x; /* always safe */

Code

#include <stdio.h>
#include <string.h>

/* Aliasing prevents optimization */
void copy_with_aliasing(int *a, int *b) {
    *a = 5;
    *b = 10;
    /* Compiler must reload *a because a and b might overlap */
    printf("a = %d\n", *a); /* Could be 5 or 10 */
}

/* WRONG: violates strict aliasing rule */
float int_bits_to_float_BAD(int i) {
    /* Accessing int memory as float is undefined behavior */
    /* return *(float *)&i; */  /* DO NOT DO THIS */
    return 0.0f; /* placeholder */
}

/* CORRECT: use memcpy for type punning (always safe) */
float int_bits_to_float_GOOD(int i) {
    float f;
    memcpy(&f, &i, sizeof(f)); /* safe type punning */
    return f;
}

/* CORRECT: use union for type punning (C99 allows this) */
float int_bits_to_float_union(int i) {
    union { int i; float f; } u;
    u.i = i;
    return u.f;
}

int main(void) {
    int x = 42;

    /* Demonstrating aliasing */
    copy_with_aliasing(&x, &x); /* a and b alias! a = 10 */

    /* char* can alias anything (exception to strict aliasing) */
    char *bytes = (char *)&x;
    printf("First byte of x: 0x%02x\n", (unsigned char)bytes[0]);

    /* Safe type punning with memcpy */
    int bits = 0x40490FDB; /* IEEE 754 for approx pi */
    float pi = int_bits_to_float_GOOD(bits);
    printf("pi approx: %f\n", pi); /* ~3.141593 */

    return 0;
}

a = 10
First byte of x: 0x0a
pi approx: 3.141593
(byte order is platform-dependent; shown for little-endian)

Key Points

•Aliasing: two pointers pointing to the same memory location
•Compilers must be conservative with aliased pointers, preventing optimizations
•Strict aliasing rule: accessing memory through an incompatible pointer type is UB
•char* can alias any type -- the one universal exception
•Use memcpy for safe type punning, not pointer casts

Gotchas

•Casting int* to float* and dereferencing violates strict aliasing -- use memcpy or union instead
•-fstrict-aliasing at -O2 can cause code that 'worked at -O0' to break
•Type-punning through pointer casts is the number one source of strict aliasing bugs
•union type punning is well-defined in C99 but technically UB in C++ (though compilers allow it)

Pointer aliasing means two pointers access the same memory. The strict aliasing rule says you can only access memory through a compatible type (or char *). Violating it is UB. Use memcpy for safe type punning, not pointer casts.

•Strict aliasing: access memory only through compatible types or char*
•Use memcpy for type punning, not pointer casts

#include <stdio.h>
#include <string.h>

int main(void) {
    int x = 0x40490FDB;

    /* WRONG: strict aliasing violation */
    /* float f = *(float *)&x; */

    /* CORRECT: memcpy is always safe */
    float f;
    memcpy(&f, &x, sizeof(f));
    printf("%f\n", f); /* ~3.141593 */

    /* char* can alias anything */
    char *bytes = (char *)&x;
    printf("0x%02x\n", (unsigned char)bytes[0]);
    return 0;
}

3.141593
0xdb
(byte value is platform-dependent; shown for little-endian)

Code may work at -O0 but break at -O2 due to strict aliasing optimizations

Question 12 / 15

How do you read complex C declarations using the cdecl (clockwise/spiral) rule?

Complex C declarations can be read using the right-left rule (also called clockwise/spiral rule):

Steps:

Start at the variable name (or innermost identifier)
Move right until you hit ) or end of declaration
Move left until you hit ( or reach the beginning
Repeat until the entire declaration is consumed

Examples:

int *p -- p is a pointer to int

int *p[10] -- p is an array of 10 pointers to int

int (*p)[10] -- p is a pointer to an array of 10 ints

int *(*p)(int) -- p is a pointer to a function taking int, returning int*

int (*(*fp)(int, int))(double) -- fp is a pointer to a function (taking int, int) returning a pointer to a function (taking double) returning int

The cdecl tool: A command-line utility that translates between C declarations and English:

cdecl> explain int (*(*fp)(int))(double)
declare fp as pointer to function (int) returning pointer to function (double) returning int

Pseudo Code

Right-Left Rule:
1. Find the identifier
2. Look right: [] means 'array of', () means 'function taking'
3. Look left: * means 'pointer to', type means 'returning/of type'
4. Alternate right-left, respecting parentheses

Example: int *(*fp[5])(int)
  fp -> array of 5 -> pointer to -> function(int) -> returning int*
  'fp is an array of 5 pointers to functions taking int, returning int*'

Code

#include <stdio.h>

/* Example 1: int *p[5] */
/* p is an array of 5 pointers to int */

/* Example 2: int (*p)[5] */
/* p is a pointer to an array of 5 ints */

/* Example 3: int (*fp)(int, int) */
/* fp is a pointer to a function taking (int,int) returning int */

/* Example 4: int *(*fp)(int) */
/* fp is a pointer to a function taking int, returning int* */

/* Example 5: Complex -- array of function pointers */
int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

int main(void) {
    /* int (*ops[2])(int, int):
     * ops is an array of 2 pointers to functions
     * taking (int,int) returning int */
    int (*ops[2])(int, int) = {add, sub};

    for (int i = 0; i < 2; i++) {
        printf("result: %d\n", ops[i](10, 3));
    }
    /* Output: result: 13 \n result: 7 */

    /* Equivalent with typedef (much clearer) */
    typedef int (*BinOp)(int, int);
    BinOp ops2[2] = {add, sub};
    printf("typedef version: %d\n", ops2[0](5, 3)); /* 8 */

    /* signal() declaration decoded:
     * void (*signal(int sig, void (*handler)(int)))(int);
     * signal is a function taking (int, pointer-to-function(int)->void)
     * returning pointer-to-function(int)->void */

    return 0;
}

result: 13
result: 7
typedef version: 8

Key Points

•Right-left rule: start at identifier, go right, then left, alternating
•[] and () bind tighter than * -- parentheses override this
•The cdecl command-line tool converts between C declarations and English
•signal() has one of the most infamous complex declarations in C
•Always use typedef to simplify complex declarations in real code

Gotchas

•Forgetting operator precedence: int *p[5] is array of pointers, int (*p)[5] is pointer to array
•Nested function pointers become unreadable fast -- always use typedef
•The spiral/clockwise rule is a simplification; the standard defines it via declarator grammar
•cdecl may not handle all GCC extensions like __attribute__

Use the right-left rule: start at the identifier, read right (arrays [], functions ()), then left (* pointer, type), alternating and respecting parentheses. Example: int *(*fp)(int) -- fp is a pointer to a function(int) returning int*.

•Right-left rule: alternate right then left from the identifier
•Use typedef to make complex declarations readable

#include <stdio.h>

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

int main(void) {
    /* int (*ops[2])(int, int):
     * ops: array of 2 pointers to function(int,int)->int */
    int (*ops[2])(int, int) = {add, sub};
    printf("%d %d\n", ops[0](3, 4), ops[1](10, 3)); /* 7 7 */
    return 0;
}

7 7

[] and () bind tighter than * -- parentheses are essential for changing meaning

Question 13 / 15

What are arrays of function pointers (dispatch tables / jump tables) and when do you use them?

An array of function pointers (dispatch table or jump table) stores pointers to functions with the same signature in an array, allowing you to call functions by index.

Why use them:

Replace long if-else/switch chains with O(1) dispatch
State machines -- each state is a function, transitions are index changes
Command interpreters -- map command codes to handler functions
Virtual method tables (vtables) -- how C++ implements polymorphism under the hood
Plugin systems -- dynamically loaded function tables

Declaration:

return_type (*array_name[SIZE])(param_types) = {func1, func2, ...};

Or with typedef:

typedef return_type (*Handler)(param_types);
Handler table[SIZE] = {func1, func2, ...};

Pseudo Code

1. Define functions with the same signature
2. Create array: typedef ret (*Handler)(params);
3. Populate: Handler table[] = {f1, f2, f3, ...};
4. Dispatch: table[index](args);

Replaces:
  switch(op) {
    case 0: f1(args); break;
    case 1: f2(args); break;
    ...
  }
With:
  table[op](args);

Code

#include <stdio.h>

/* Calculator with dispatch table */
double calc_add(double a, double b) { return a + b; }
double calc_sub(double a, double b) { return a - b; }
double calc_mul(double a, double b) { return a * b; }
double calc_div(double a, double b) {
    if (b == 0.0) { printf("Error: division by zero\n"); return 0.0; }
    return a / b;
}

typedef double (*CalcOp)(double, double);

int main(void) {
    /* Dispatch table: index maps to operation */
    CalcOp ops[] = {calc_add, calc_sub, calc_mul, calc_div};
    const char *names[] = {"+", "-", "*", "/"};
    int num_ops = sizeof(ops) / sizeof(ops[0]);

    double a = 10.0, b = 3.0;
    for (int i = 0; i < num_ops; i++) {
        printf("%.1f %s %.1f = %.2f\n", a, names[i], b, ops[i](a, b));
    }
    /* Output:
     * 10.0 + 3.0 = 13.00
     * 10.0 - 3.0 = 7.00
     * 10.0 * 3.0 = 30.00
     * 10.0 / 3.0 = 3.33
     */

    /* Direct dispatch by index (O(1) instead of switch) */
    int operation = 2; /* multiply */
    printf("Result: %.2f\n", ops[operation](5.0, 4.0)); /* 20.00 */

    return 0;
}

Key Points

•Array of function pointers enables O(1) dispatch by index
•Replaces long switch/if-else chains with cleaner, extensible code
•Used in state machines, command dispatchers, calculators, and vtable implementations
•typedef makes the declaration much more readable
•All functions in the table must share the same signature

Gotchas

•Out-of-bounds index leads to calling a garbage address -- always validate the index
•All functions must have the exact same signature -- no implicit conversions
•NULL entries in the table should be checked before calling
•If the table is const, declare it as: const CalcOp ops[] or CalcOp const ops[]

An array of function pointers stores functions by index for O(1) dispatch. Use typedef for the function type, then create an array. Call with table[index](args). Replaces switch/if-else chains.

•O(1) function dispatch by index instead of switch/if-else
•All functions must share the same signature

#include <stdio.h>

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

typedef int (*Op)(int, int);

int main(void) {
    Op table[] = {add, sub};
    printf("%d\n", table[0](10, 3)); /* 13 */
    printf("%d\n", table[1](10, 3)); /* 7  */
    return 0;
}

13
7

Always bounds-check the index before calling through the table

Question 14 / 15

How do you implement generic programming in C using void pointers and callbacks?

C does not have templates or generics like C++ or Java. Instead, generic programming in C is achieved through:

void pointers (void *) for type-erased data
Function pointer callbacks for type-specific operations
size_t parameters for element sizes

This is the pattern used throughout the C standard library:

qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *))
bsearch() with the same pattern
memcpy(), memmove(), memset() operate on raw bytes

The pattern:

void generic_function(void *data, size_t elem_size, size_t count,
                      ReturnType (*operation)(const void *, const void *));

The caller provides:

Data as void *
Element size so the function can navigate the array
A callback that knows the actual type and performs type-specific logic

Pseudo Code

1. Accept data as void* with size_t element size
2. Navigate array: (char*)base + i * elem_size
3. Accept callback for type-specific operations
4. Callback casts void* to actual type internally
5. The generic function never knows the actual type

Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Generic swap: works for any type */
void generic_swap(void *a, void *b, size_t size) {
    char temp[256]; /* or use malloc for safety */
    memcpy(temp, a, size);
    memcpy(a, b, size);
    memcpy(b, temp, size);
}

/* Generic find: linear search for any type */
void *generic_find(void *base, size_t count, size_t elem_size,
                   const void *target,
                   int (*compare)(const void *, const void *)) {
    for (size_t i = 0; i < count; i++) {
        void *elem = (char *)base + i * elem_size;
        if (compare(elem, target) == 0) {
            return elem;
        }
    }
    return NULL;
}

/* Generic foreach: apply a function to every element */
void generic_foreach(void *base, size_t count, size_t elem_size,
                     void (*action)(void *elem)) {
    for (size_t i = 0; i < count; i++) {
        action((char *)base + i * elem_size);
    }
}

/* Type-specific callbacks */
int compare_int(const void *a, const void *b) {
    return *(const int *)a - *(const int *)b;
}

void print_int(void *elem) {
    printf("%d ", *(int *)elem);
}

int compare_double(const void *a, const void *b) {
    double da = *(const double *)a, db = *(const double *)b;
    return (da > db) - (da < db);
}

int main(void) {
    /* Generic swap with ints */
    int a = 5, b = 10;
    generic_swap(&a, &b, sizeof(int));
    printf("a=%d b=%d\n", a, b); /* a=10 b=5 */

    /* Generic swap with doubles */
    double x = 1.1, y = 2.2;
    generic_swap(&x, &y, sizeof(double));
    printf("x=%.1f y=%.1f\n", x, y); /* x=2.2 y=1.1 */

    /* Generic find */
    int arr[] = {10, 20, 30, 40, 50};
    int target = 30;
    int *found = (int *)generic_find(arr, 5, sizeof(int), &target, compare_int);
    if (found) printf("Found: %d\n", *found); /* Found: 30 */

    /* Generic foreach */
    printf("Elements: ");
    generic_foreach(arr, 5, sizeof(int), print_int);
    printf("\n"); /* Elements: 10 20 30 40 50 */

    return 0;
}

a=10 b=5
x=2.2 y=1.1
Found: 30
Elements: 10 20 30 40 50

Key Points

•void* for type-erased data + size_t for element size + callbacks for type-specific logic
•Navigate generic arrays with (char*)base + i * elem_size
•qsort/bsearch are the canonical examples of this pattern
•The generic function never knows the actual type; callbacks handle casting
•memcpy is the safe way to copy void* data of known size

Gotchas

•No type safety: passing the wrong size or callback is a silent bug that corrupts memory
•Performance overhead from function pointer calls (no inlining possible)
•Stack-allocated temp buffer in swap has size limits; use malloc for large elements
•Comparing doubles by subtraction and casting to int loses precision -- use the (a > b) - (a < b) pattern

Use void * for data, size_t for element size, and function pointer callbacks for type-specific operations. Navigate arrays with (char *)base + i * elem_size. This is how qsort and bsearch work.

•void* + size_t + callbacks = generic programming in C
•qsort is the canonical example of this pattern

#include <stdio.h>
#include <string.h>

void generic_swap(void *a, void *b, size_t size) {
    char tmp[size];
    memcpy(tmp, a, size);
    memcpy(a, b, size);
    memcpy(b, tmp, size);
}

int main(void) {
    int x = 5, y = 10;
    generic_swap(&x, &y, sizeof(int));
    printf("%d %d\n", x, y); /* 10 5 */
    return 0;
}

10 5

No compile-time type safety -- wrong size parameter silently corrupts memory

Question 15 / 15

What are dangling pointers and how can you detect and prevent them?

A dangling pointer is a pointer that references memory that has been freed, deallocated, or has gone out of scope. Dereferencing a dangling pointer is undefined behavior -- it may crash, return garbage, or silently corrupt data.

Common causes:

Use after free: Accessing memory after free() is called
Returning address of local variable: The variable is destroyed when the function returns
Scope exit: A pointer to a block-scoped variable used after the block ends
Stale pointers in data structures: Linked list node freed but other nodes still point to it

Prevention strategies:

Set pointer to NULL after free: free(p); p = NULL;
Use a macro: #define SAFE_FREE(p) do { free(p); (p) = NULL; } while(0)
Ownership semantics: Document who owns (and frees) each allocation
Scope discipline: Never return addresses of local variables
Static analysis tools: Clang analyzer, Coverity, cppcheck
Runtime tools: Valgrind, AddressSanitizer (ASan)

Detection tools:

Valgrind: Reports "use after free" errors
ASan (AddressSanitizer): Compile with -fsanitize=address for instant detection
Static analyzers: Catch many patterns at compile time

Pseudo Code

Common dangling pointer patterns:

1. Use after free:
   free(p);
   *p = 10;  /* DANGLING: p still holds the old address */

2. Returning local address:
   int *bad() {
     int x = 42;
     return &x;  /* DANGLING: x destroyed on return */
   }

3. Stale reference:
   int *p;
   { int x = 10; p = &x; }
   *p = 20;  /* DANGLING: x out of scope */

Prevention:
   free(p); p = NULL;  /* NULL dereference is easier to debug */

Code

#include <stdio.h>
#include <stdlib.h>

/* Safe free macro: frees and NULLs the pointer */
#define SAFE_FREE(p) do { free(p); (p) = NULL; } while(0)

/* BAD: returns address of local variable */
/*
int *dangling_example(void) {
    int x = 42;
    return &x;   // WARNING: address of local variable
}
*/

/* GOOD: allocate on heap to return */
int *safe_example(void) {
    int *p = (int *)malloc(sizeof(int));
    if (p) *p = 42;
    return p; /* Caller must free this */
}

int main(void) {
    /* Scenario 1: Use after free */
    int *p = (int *)malloc(sizeof(int));
    *p = 100;
    printf("Before free: %d\n", *p); /* 100 */
    free(p);
    /* printf("%d\n", *p); */  /* DANGLING: undefined behavior! */
    p = NULL; /* Best practice: NULL after free */

    /* Scenario 2: Using SAFE_FREE macro */
    int *q = (int *)malloc(sizeof(int));
    *q = 200;
    SAFE_FREE(q);
    /* q is now NULL -- dereferencing will crash predictably */
    if (q == NULL) {
        printf("q is safely NULL\n");
    }

    /* Scenario 3: Safe return from function */
    int *r = safe_example();
    printf("Safe value: %d\n", *r); /* 42 */
    SAFE_FREE(r);

    return 0;
}

/*
 * Compile with AddressSanitizer to detect dangling pointers:
 *   gcc -fsanitize=address -g program.c -o program
 *
 * Run with Valgrind:
 *   valgrind --leak-check=full ./program
 */

Before free: 100
q is safely NULL
Safe value: 42

Key Points

•A dangling pointer references freed/out-of-scope memory
•Dereferencing one is undefined behavior: crash, corruption, or silent success
•Always set pointers to NULL after free (NULL deref is easier to debug than random corruption)
•Never return the address of a local variable -- use heap allocation instead
•AddressSanitizer (-fsanitize=address) catches use-after-free at runtime

Gotchas

•Use-after-free may appear to work because freed memory is not immediately reclaimed by the OS
•Setting p = NULL only NULLs that one pointer -- other copies of the pointer remain dangling
•Dangling pointers to stack memory are especially dangerous: the stack gets reused immediately
•Double free is a special case: freeing a dangling pointer that was already freed

A dangling pointer references freed or out-of-scope memory. Prevent by setting pointers to NULL after free, never returning addresses of locals, and using tools like ASan or Valgrind to detect.

•Always NULL pointers after free
•Use AddressSanitizer or Valgrind to detect dangling pointer use

#include <stdio.h>
#include <stdlib.h>

#define SAFE_FREE(p) do { free(p); (p) = NULL; } while(0)

int main(void) {
    int *p = (int *)malloc(sizeof(int));
    *p = 42;
    SAFE_FREE(p);          /* free and set to NULL */
    if (p == NULL)
        printf("safely nulled\n");
    /* Compile with: gcc -fsanitize=address to detect use-after-free */
    return 0;
}

safely nulled

Other copies of the pointer remain dangling even after you NULL one copy

Built by onllm.dev

Home GitHub Support awesomePrep

What is a double pointer (pointer to pointer) and when do you use it?

How do you declare and use function pointers in C?

What are callback functions in C and how do you implement the callback pattern?

What is the difference between a pointer to an array and an array of pointers?

Explain all const pointer variations: const int*, int* const, and const int* const.

How do you declare a pointer to a function that returns a pointer?

What are the rules for void pointer arithmetic in C?

What are near and far pointers in C, and are they still relevant?

What are opaque pointers and how do they enable data hiding in C?

What does the restrict keyword do in C?

What is pointer aliasing and why does it matter for optimization?

How do you read complex C declarations using the cdecl (clockwise/spiral) rule?

What are arrays of function pointers (dispatch tables / jump tables) and when do you use them?

How do you implement generic programming in C using void pointers and callbacks?

What are dangling pointers and how can you detect and prevent them?

Advanced Pointers

Explain all const pointer variations: const int, int const, and const int* const.