🔢 Reading C Pointer Declarations — Simple to Complex
0%
C Programming  ·  Pointers  ·  Declaration Syntax

Reading C Pointer
Declarations

C pointer declarations look intimidating but follow three simple rules. Once you learn to read them right-to-left from the identifier, every declaration — no matter how complex — becomes readable in seconds. This lesson covers every type from the book.

🔁
Rule 1 — Start at name
Always begin at the identifier p. Then read outward using the spiral/clockwise rule.
➡️
Rule 2 — Right before left
[] and () on the right bind tighter than * on the left.
🔒
Rule 3 — Parentheses first
Parentheses around *p force pointer-ness before array or function.
Level 1 🟢 Basic Pointer Declarations
D1
int *p
The most fundamental pointer — p is a pointer to an integer
Pointer to int
How to read it
Start at p. Look right — nothing. Look left — *. So p is a pointer. Look further left — int. So p is a pointer to an int. Done.
int *p;
* → p is a POINTER
int → points to integer
Plain English
p is a pointer to an integer quantity. It stores the address of an int variable.
d1_basic_pointer.c
C
#include <stdio.h>
int main() {
    int  x = 42;
    int *p;          /* p is a pointer to int          */
    p = &x;          /* p now holds address of x       */
    printf("value: %d\n",   *p);  /* dereference → 42  */
    printf("address: %p\n", (void*)p);
    return 0;
}
D2
int *p[10]
Array of pointers — [] beats * — p is an array, not a pointer
Array of Pointers
Start at p. Look right — [10] → p is a 10-element array. Look left — * → of pointers. Look left again — int → to integers. The [] on the right wins over * on the left because right-side operators bind first.
int *p[10];
[10] → array of 10 elements
* → each element is a pointer
int → pointer-to-integer
Plain English
p is a 10-element array of pointers to integer quantities. Each of the 10 slots holds the address of a different int.
d2_array_of_ptrs.c
C
#include <stdio.h>
int main() {
    int  a=1, b=2, c=3;
    int *p[10];       /* 10-element array of int pointers */
    p[0] = &a;
    p[1] = &b;
    p[2] = &c;
    printf("%d %d %d\n", *p[0], *p[1], *p[2]); /* 1 2 3 */
    return 0;
}
Key difference: int *p[10] vs int (*p)[10]
Without parentheses — int *p[10] — p is an array of 10 pointers. With parentheses — int (*p)[10] — p is a pointer to a 10-element int array. Parentheses completely change the meaning.
D3
int (*p)[10]
Pointer to an array — parentheses force p to be the pointer
Pointer to Array
Parentheses around *p lock in pointer-ness first. Start at p. Parentheses say: go left first inside — * → p is a pointer. Now parentheses end. Go right — [10] → to a 10-element array. Go left — int → of integers.
int (*p)[10];
(*p) → p is a POINTER
[10] → to a 10-element array
int → array of integers
Plain English
p is a pointer to a 10-element integer array. This is used to iterate over 2D arrays row by row.
d3_ptr_to_array.c
C
#include <stdio.h>
int main() {
    int matrix[3][10] = {{1,2},{3,4},{5,6}};
    int (*p)[10] = matrix; /* p points to first ROW */
    printf("Row 0: %d %d\n", p[0][0], p[0][1]); /* 1 2 */
    p++;                    /* advance by one FULL ROW       */
    printf("Row 1: %d %d\n", p[0][0], p[0][1]); /* 3 4 */
    return 0;
}
Level 2 🟡 Functions — Returning Pointers & Pointers to Functions
D4
int *p(void)
Function that returns a pointer — p is a function, not a pointer
Function → *int
Start at p. Look right — (void) → p is a function taking no arguments. Look left — * → returns a pointer. Look further left — int → to an integer. No parentheses around *p, so (void) on the right wins over *.
int *p(void);
(void) → p is a FUNCTION
void → takes no argument
* → returns a POINTER
int → to an integer
Plain English
p is a function that accepts no arguments and returns a pointer to an integer quantity.
d4_fn_returns_ptr.c
C
#include <stdio.h>
#include <stdlib.h>

int *p(void) {           /* function returning int* */
    int *arr = (int*)malloc(5 * sizeof(int));
    for(int i=0;i<5;i++) arr[i] = i * 10;
    return arr;            /* returns pointer to int  */
}

int main() {
    int *result = p();    /* call function, get int* */
    printf("%d %d %d\n", result[0], result[1], result[2]);
    free(result);
    return 0;
}
D5
int (*p)(void)
Pointer to a function — parentheses force p to be the pointer
Pointer to Function
Parentheses around *p lock in pointer-ness. Start at p. Inside parens go left — * → p is a pointer. Parens end. Go right — (void) → to a function taking no arguments. Go left — int → that returns int. This is how you declare a function pointer — use it to store and call functions dynamically.
int (*p)(void);
(*p) → p is a POINTER
(void) → to a FUNCTION taking no args
int → that returns integer
Plain English
p is a pointer to a function that accepts no arguments and returns an integer quantity.
d5_ptr_to_fn.c
C
#include <stdio.h>

int sayHello(void) { printf("Hello!\n"); return 1; }
int sayBye(void)   { printf("Bye!\n");   return 0; }

int main() {
    int (*p)(void);   /* pointer to function()→int */
    p = sayHello;      /* point p at sayHello       */
    p();               /* call via pointer → Hello! */
    p = sayBye;        /* re-point at sayBye        */
    p();               /* call via pointer → Bye!   */
    return 0;
}
Function pointers are how C achieves runtime polymorphism — the same pointer variable p can call different functions depending on what it is assigned. This is the foundation of callbacks, dispatch tables, and plugin systems.
Level 3 🟠 Functions with Parameters — char* and char*[]
D6
int p(char *a)
Function taking a char pointer, returning int — the simplest function with a param
fn(char*) → int
int p(char *a);
(char *a) → p is a FUNCTION
char *a → takes pointer to character
int → returns integer
Plain English
p is a function that accepts an argument which is a pointer to a character, and returns an integer quantity. Classic signature — e.g. strlen(char *s).
d6_fn_charptr.c
C
#include <stdio.h>

/* p is a function(char *a) → int */
int p(char *a) {
    int count = 0;
    while(*a++) count++;   /* count chars until NULL */
    return count;
}

int main() {
    printf("Length: %d\n", p("Ananta")); /* 6 */
    return 0;
}
D7
int *p(char *a)
Function takes char*, returns int* — function returning a pointer
fn(char*) → int*
int *p(char *a);
(char *a) → p is a FUNCTION
char *a → takes pointer to char
* → returns a POINTER
int → to an integer
Plain English
p is a function that accepts an argument which is a pointer to a character, and returns a pointer to an integer quantity.
D8
int (*p)(char *a)
Pointer to a function that takes char* and returns int
Ptr to fn(char*) → int
Now p is a pointer to a function. The parentheses around *p lock it as pointer first. Then (char *a) describes what function it points to: one that takes a pointer-to-char. And int on the far left is what that function returns.
int (*p)(char *a);
(*p) → p is a POINTER
(char *a) → to a FUNCTION taking char*
int → that returns integer
Plain English
p is a pointer to a function that accepts an argument which is a pointer to a character, and returns an integer quantity.
d8_ptr_to_fn_charptr.c
C
#include <stdio.h>
#include <string.h>

int myLen(char *s) { return (int)strlen(s); }
int myVow(char *s) {  /* count vowels */
    int n=0;
    while(*s){ if(strchr("aeiouAEIOU",*s)) n++; s++; }
    return n;
}

int main() {
    int (*p)(char *a);  /* pointer to fn(char*)→int */

    p = myLen;
    printf("Length : %d\n", p("Ananta")); /* 6  */

    p = myVow;
    printf("Vowels : %d\n", p("Ananta")); /* 3  */
    return 0;
}
Level 4 🔴 Array Parameters — char *a[] and char (*a)[]
D9
int p(char *a[])
Function taking array of char pointers — the signature of main()
fn(char*[]) → int
The parameter char *a[] is an array of pointers to characters. a is [] → array, then * → of pointers, then char → to characters. This is exactly the type of argv in main(int argc, char *argv[]) — an array of strings.
int p(char *a[]);
p(...) → p is a FUNCTION
a[] → param is an ARRAY
char * → of pointers to char
int → returns integer
Plain English
p is a function that accepts an argument which is an array of pointers to characters, and returns an integer quantity. This is identical to main(int argc, char *argv[]).
d9_fn_argv_style.c
C
#include <stdio.h>

/* p takes array of char pointers — like argv */
int p(char *a[]) {
    int i = 0;
    while(a[i] != NULL) {
        printf("[%d] %s\n", i, a[i]);
        i++;
    }
    return i;
}

int main() {
    char *words[] = { "Apple", "Mango", "Banana", NULL };
    int count = p(words);
    printf("Count: %d\n", count);  /* 3 */
    return 0;
}
D10
int p(char (*a)[])
Function taking pointer to a character array — pointer to string
fn(ptr-to-char[]) → int
int p(char (*a)[]);
p(...) → p is a FUNCTION
(*a) → param a is a POINTER
[] → to a character array
int → returns integer
Plain English
p is a function that accepts an argument which is a pointer to a character array, and returns an integer quantity.
Level 5 🔥 Array of Function Pointers — Most Complex Forms
D11
int (*p[10])(void)
10-element array of pointers to functions — a dispatch table
Array of fn ptrs
Start at p. Look right inside parens — [10] → p is a 10-element array. Look left inside parens — * → of pointers. Parens end. Look right — (void) → to functions taking no args. Look left — int → each returning an integer. This is a dispatch table: 10 function pointers in one array.
int (*p[10])(void);
p[10] → array of 10 elements
* → each is a POINTER
(void) → to FUNCTIONS taking no args
int → each returns integer
Plain English
p is a 10-element array of pointers to functions; each function accepts no argument and returns an integer quantity.
d11_array_of_fn_ptrs.c
C — Dispatch Table
#include <stdio.h>

int op0(void){ return 0; }
int op1(void){ return 1; }
int op2(void){ return 4; }

int main() {
    /* 10-element array of pointers to fn()→int */
    int (*p[10])(void);

    p[0] = op0;   /* p[0] points to op0 */
    p[1] = op1;   /* p[1] points to op1 */
    p[2] = op2;   /* p[2] points to op2 */

    for(int i=0; i<3; i++)
        printf("p[%d]() = %d\n", i, p[i]()); /* call each */
    return 0;
}
output
p[0]() = 0
p[1]() = 1
p[2]() = 4
D12
int (*p[10])(char a)
10 function pointers, each taking a char and returning int
Array of fn(char) ptrs
int (*p[10])(char a);
p[10] → array of 10
* → pointers
(char a) → to fn taking a char
int → returning integer
Plain English
p is a 10-element array of pointers to functions; each function accepts an argument which is a character, and returns an integer quantity.
D13
int *(*p[10])(char *a)
The most complex form — array of function pointers, each returning int*
Array of fn(char*)→int* ptrs
Read step by step: p → look right inside parens → [10] → 10-element array → look left inside parens → * → of pointers → parens end → look right → (char *a) → to functions taking pointer-to-char → look left → * → each returns a pointer → look far left → int → to an integer.
int *(*p[10])(char *a);
p[10] → array of 10
* inside () → each is a pointer
(char *a) → to fn taking char*
* outside → each returns a POINTER
int → to an integer
Plain English
p is a 10-element array of pointers to functions; each function accepts an argument which is a pointer to a character, and returns a pointer to an integer quantity. The most complex declaration from the book.
Summary 📋 Quick Reference — All Declarations at a Glance
The Clockwise/Spiral Rule — 3 Steps
Step 1 — Start at the identifier (p). Say "p is…"

Step 2 — Go right first: if you see [n] → "array of n", if you see (…) → "function taking…". Hit closing paren or end? Stop going right.

Step 3 — Go left: if you see * → "pointer to". If you see a type name (int, char) → that's what it points to or returns. If there are parens around *p → go left inside the parens first, then continue outward.

Repeat steps 2–3 spiralling outward until you have read the entire declaration.
int *p
p is a pointer to int
int *p[10]
p is array[10] of int pointers
int (*p)[10]
p is pointer to int[10] array
int *p(void)
p is function() returning int*
int (*p)(void)
p is pointer to function()→int
int p(char *a)
p is function(char*)→int
int *p(char *a)
p is function(char*)→int*
int (*p)(char *a)
p is pointer to function(char*)→int
int p(char *a[])
p is function(char*[])→int (like main)
int (*p[10])(void)
p is array[10] of ptrs to fn()→int
int (*p[10])(char a)
p is array[10] of ptrs to fn(char)→int
int *(*p[10])(char *a)
p is array[10] of ptrs to fn(char*)→int*
Parentheses change everything. int *p[10] and int (*p)[10] look almost identical but mean completely different things. The first is an array of pointers; the second is a pointer to an array. When in doubt, add parentheses around *p to force pointer-ness.
checklist
  • Reading rule: Start at identifier p → go right first ([] and () bind before *) → go left (* = pointer, type = what it points to). Repeat spiralling outward.
  • D1 — int *p: p is a pointer to int. The simplest case. * on the left of p with nothing on the right.
  • D2 — int *p[10]: p is an ARRAY of 10 pointers to int. [] on right beats * on left — p is array first.
  • D3 — int (*p)[10]: p is a POINTER to a 10-element int array. Parens force pointer before []. Opposite of D2.
  • D4 — int *p(void): p is a FUNCTION taking no args, returning int*. () on right beats * — p is function first.
  • D5 — int (*p)(void): p is a POINTER to a function()→int. Parens force pointer before (). Function pointer.
  • D8 — int (*p)(char *a): p is a pointer to a function taking char* and returning int. Function pointer with parameter.
  • D9 — int p(char *a[]): p is a function taking array of char pointers (= char**). Exactly like main()'s argv.
  • D11 — int (*p[10])(void): p is a 10-element array of pointers to fn()→int. A dispatch table. Read p[10] first (array), then * (of pointers), then (void) (to functions).
  • D13 — int *(*p[10])(char *a): p is array[10] of pointers to functions(char*)→int*. Most complex. Two *: one for the pointer-to-function, one for the return type.