Uncommon Pointer & Array Examples

Array name is already a pointer — no & needed

arr and &arr[0] are the same address — you can use arr like a pointer directly

Array = Pointer

Most people write int *p = &arr[0] to get a pointer to the first element. But the array name itself is already that pointer. Writing int *p = arr is identical. This means arr[2] and *(arr+2) and *(p+2) and p[2] all produce the exact same value — four different syntaxes for one operation.

arr in memory — arr == &arr[0] == p

e1_array_is_pointer.c

#include <stdio.h>

int main() {
    int  arr[] = {10, 20, 30, 40, 50};
    int *p = arr;   /* same as &arr[0] — no & needed */

    /* All four lines print the SAME value: 30 */
    printf("arr[2]      = %d\n",  arr[2]);    /* normal index     */
    printf("*(arr+2)    = %d\n",  *(arr+2)); /* pointer math     */
    printf("*(p+2)      = %d\n",  *(p+2));  /* via pointer      */
    printf("p[2]        = %d\n",   p[2]);   /* pointer as array */

    /* Proof: same address */
    printf("\narr    addr = %p\n", (void*)arr);
    printf("&arr[0] addr = %p\n", (void*)&arr[0]);
    printf("p      addr = %p\n", (void*)p);
    return 0;
}

output

arr[2]      = 30
*(arr+2)    = 30
*(p+2)      = 30
p[2]        = 30

arr    addr = 0x7ffd1a2b3c40
&arr[0] addr = 0x7ffd1a2b3c40
p      addr = 0x7ffd1a2b3c40

💡

Uncommon fact: you can use subscript [ ] on any pointer, not just arrays. p[2] is literally defined as *(p+2) in C. Even this works: 2[p] — because 2[p] = *(2+p) = *(p+2). Addition is commutative.

e2 — pointer doing subscript

Pointer subscript — walking a string with p[i] instead of p++

A char* can be subscripted like an array — and the index can even go negative

Pointer [ ] Access

A char* pointer can use [ ] just like an array — because they are the same operation. The uncommon trick: if you advance the pointer first (p++ or p += k), then p[-1] gives the character before the current position. Negative subscripts are legal in C as long as the address remains within the original array's bounds.

e2_negative_subscript.c

#include <stdio.h>

int main() {
    char word[] = "Ananta";
    char *p = word;         /* p → 'A'                     */

    p += 3;                 /* advance: p → 'n' (index 3)  */

    printf("p[0]  = %c\n",  p[0]);   /* 'n'  — current position     */
    printf("p[1]  = %c\n",  p[1]);   /* 't'  — one ahead            */
    printf("p[-1] = %c\n",  p[-1]); /* 'a'  — one BEHIND (legal!)  */
    printf("p[-3] = %c\n",  p[-3]); /* 'A'  — back to start        */

    /* Reverse print using negative subscript */
    int len = 6;
    p = word + len - 1;    /* p → last char 'a'           */
    printf("Reversed: ");
    for(int i = 0; i < len; i++)
        printf("%c", p[-i]); /* p[0] p[-1] p[-2] ...        */
    printf("\n");
    return 0;
}

output

p[0]  = n
p[1]  = t
p[-1] = a
p[-3] = A
Reversed: atnanA

💡

Negative subscript is legal as long as the computed address stays inside the original array. p[-1] just means *(p-1) — one step before wherever p currently points. This is used in audio DSP buffers, circular queues, and boundary checks.

e3 — pointer to the middle

Pointer to the middle — split one array into two views

Two pointers, same array — left half and right half — no copying needed

Mid-Array Pointer

You can point into the middle of an existing array and treat it as a separate array — no copy, no malloc. int *right = arr + 5 means right[0] is arr[5], right[1] is arr[6], and so on. This is how C handles substrings, sub-arrays, and efficient partition algorithms — by handing a pointer to the relevant position instead of copying data.

left points to arr[0], right points to arr[5] — same memory, two views

e3_mid_pointer.c

#include <stdio.h>

/* Print n elements via pointer — reusable */
void printN(const int *p, int n, const char *label) {
    printf("%-8s: [ ", label);
    for(int i = 0; i < n; i++) printf("%d ", p[i]);
    printf("]\n");
}

int main() {
    int  arr[] = {10,20,30,40,50,60,70,80,90,100};

    int *left  = arr;      /* view of first half   */
    int *right = arr + 5; /* view of second half  */

    printN(left,  5, "left");   /* 10 20 30 40 50  */
    printN(right, 5, "right");  /* 60 70 80 90 100 */

    /* right[0] IS arr[5] — same memory */
    right[0] = 999;
    printf("arr[5] after right[0]=999: %d\n", arr[5]); /* 999 */

    /* Distance between two pointers */
    printf("right - left = %td elements\n", right - left); /* 5 */
    return 0;
}

output

left    : [ 10 20 30 40 50 ]
right   : [ 60 70 80 90 100 ]
arr[5] after right[0]=999: 999
right - left = 5 elements

💡

No copy was made. left and right both point into the same array. Writing through right[0] changes arr[5]. This is how qsort, binary search, and merge sort work — they pass sub-array pointers, not copies.

e4 — pointer to pointer

Pointer to a pointer — int **pp — two levels of indirection

pp stores the address of p, which stores the address of x — reach x through two arrows

Double Pointer

int **pp is a pointer to a pointer to int. It stores the address of another pointer. To get to the actual integer you dereference twice: **pp. The uncommon use: you can change which variable p points to from inside a function, by passing &p as int **pp. Single pointer can change the value — double pointer can change the pointer itself.

three variables, two levels of indirection

e4_double_pointer.c

#include <stdio.h>

/* Changes which variable ptr POINTS AT — needs int** */
void redirectPtr(int **pp, int *newTarget) {
    *pp = newTarget;   /* change what p points to */
}

int main() {
    int  x  = 42;
    int  y  = 99;
    int *p  = &x;      /* p → x                   */
    int**pp  = &p;     /* pp → p                  */

    printf("*p   = %d\n",   *p);   /* 42 — through p         */
    printf("**pp = %d\n",  **pp);  /* 42 — through pp then p */

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

    /* Re-point p at y — using double pointer */
    redirectPtr(&p, &y);
    printf("*p after redirect: %d\n", *p);  /* 99 */
    return 0;
}

output

*p   = 42
**pp = 42
x after **pp=100: 100
*p after redirect: 99

💡

Single pointer modifies the value. Double pointer modifies the pointer. If a function receives int *p and does p = &y, the caller's pointer is unchanged. But with int **pp and *pp = &y, the caller's pointer is redirected. This is why scanf takes &variable — it needs a pointer to write through.

e5 — array of 5 pointers passed to a function

Array of 5 pointers — passed to a function — printed inside

int *arr[5] holds 5 addresses — function receives int **arr — dereferences each

int *arr[5] → Function

int *arr[5] is an array where each of the 5 slots holds a pointer to a different integer. When you pass this array to a function, the function receives it as int **arr — a pointer to the first element, where each element is itself a pointer. Inside the function, arr[i] is the i-th pointer, and *arr[i] is the integer it points at. Two levels: array slot → pointer → integer.

int *arr[5] — 5 slots, each holding a pointer to a different int

Declaration side

int *arr[5]
→ array of 5 slots
→ each slot is int*
arr[0] = &a (address of a)
arr[1] = &b etc.

Function side

void fn(int **arr, int n)
→ receives int** (ptr to first ptr)
arr[i] → the i-th pointer
*arr[i] → the actual integer

e5_array_of_pointers_to_fn.c

#include <stdio.h>

/* Function receives int** — array of pointers passed in */
void printAll(int **arr, int n) {
    printf("  Values via *arr[i]:\n");
    for (int i = 0; i < n; i++) {
        printf("  arr[%d] points to address %p → value = %d\n",
               i, (void*)arr[i], *arr[i]);
    }
}

/* Function doubles every value through the pointers */
void doubleAll(int **arr, int n) {
    for (int i = 0; i < n; i++)
        *arr[i] *= 2;    /* dereference and modify */
}

/* Function finds maximum by comparing through pointers */
int findMax(int **arr, int n) {
    int max = *arr[0];
    for (int i = 1; i < n; i++)
        if (*arr[i] > max) max = *arr[i];
    return max;
}

int main() {
    /* Five separate int variables */
    int a = 10, b = 20, c = 30, d = 40, e = 50;

    /* Array of 5 pointers — each holds an address */
    int *arr[5];
    arr[0] = &a;
    arr[1] = &b;
    arr[2] = &c;
    arr[3] = &d;
    arr[4] = &e;

    /* Pass array of pointers — decays to int** */
    printf("=== printAll ===\n");
    printAll(arr, 5);

    printf("\n=== doubleAll ===\n");
    doubleAll(arr, 5);    /* modifies a,b,c,d,e through pointers */
    printAll(arr, 5);

    printf("\n=== findMax ===\n");
    printf("  Max = %d\n", findMax(arr, 5));

    /* Proof: a,b,c,d,e themselves changed */
    printf("\n=== original vars after doubleAll ===\n");
    printf("  a=%d b=%d c=%d d=%d e=%d\n", a, b, c, d, e);
    return 0;
}

output

=== printAll ===
  arr[0] points to address 0x7ffd... → value = 10
  arr[1] points to address 0x7ffd... → value = 20
  arr[2] points to address 0x7ffd... → value = 30
  arr[3] points to address 0x7ffd... → value = 40
  arr[4] points to address 0x7ffd... → value = 50

=== doubleAll ===
  arr[0] points to address 0x7ffd... → value = 20
  arr[1] points to address 0x7ffd... → value = 40
  arr[2] points to address 0x7ffd... → value = 60
  arr[3] points to address 0x7ffd... → value = 80
  arr[4] points to address 0x7ffd... → value = 100

=== findMax ===
  Max = 100

=== original vars after doubleAll ===
  a=20 b=40 c=60 d=80 e=100

💡

Why does the function receive int **arr? Because int *arr[5] is an array of pointers. When an array is passed to a function, it decays to a pointer to its first element. The first element is an int*. So a pointer to int* is int**. Two-step: int *arr[5] → first element type is int* → pointer to that is int**.

The variables a, b, c, d, e actually changed after doubleAll(). The function received pointers to them and wrote through those pointers with *arr[i] *= 2. This is how C functions modify multiple separate variables — not by returning them, but by receiving their addresses and writing directly.

checklist

E1 — Array IS a pointer: int *p = arr is same as int *p = &arr[0]. All four — arr[i], *(arr+i), p[i], *(p+i) — give the same result. p[2] is defined as *(p+2).
E2 — Negative subscript: After p += 3, writing p[-1] is legal and means *(p-1) — one step back. Legal as long as address stays inside the original array.
E3 — Pointer to middle: int *right = arr + 5 creates a second view into the same array. right[0] IS arr[5] — same memory, no copy. Pointer subtraction right - left gives the distance in elements.
E4 — Double pointer: int **pp points to a pointer. *pp gives the pointer, **pp gives the value. Pass &p as int** to let a function change which variable p points at.
E5 — Array of 5 pointers: int *arr[5] — 5 slots, each an int*. Pass to function as int **arr (array decays to pointer-to-first-element, first element is int*, so pointer-to-that is int**). arr[i] = i-th pointer. *arr[i] = i-th value. Writing *arr[i] = x changes the original variable.

Uncommon Pointer& Array Examples

Uncommon Pointer
& Array Examples