int *p(char*) vs int (*p)(char*) — Complete Lesson

How to Read Each Declaration — Right Before Left

Start at p, look right first, then left — parentheses change the binding order

Reading Rule

The One Rule — Right Binds Before Left

Start at the name p. Look right — if you see () or [] they bind before the * on the left. So int *p(char *a) — p sees (char *a) on its right first → p is a function. The * then applies to the return type → it returns int*.

Putting (*p) in parentheses breaks that rule — the parens force p to bond with * first → p is a pointer. Then (char *a) on the outside describes the function it points to.

Annotated reading — both declarations broken down token by token

int *p(char *a) — step by step

① Start at p
② Right: (char *a) → p is a function taking char*
③ Left: * → return type is a pointer
④ Far left: int → pointer to int

Result: p is a function(char*) → int*

int (*p)(char *a) — step by step

① Start at p
② Parens: (*p) → p is a pointer
③ Right: (char *a) → to a function taking char*
④ Far left: int → function returns int

Result: p is a pointer to function(char*) → int

The single visual test: Is there a (*p) group? Yes → p is a pointer to a function. No → p is a function that returns a pointer. That one bracket pair is the only difference.

int *getLength(char *a) — Computes length, stores in heap, returns address

Caller receives int* — must dereference to read value — must free() when done

Function → int*

int *getLength(char *a) matches the declaration int *p(char *a) exactly. It is a function — not a pointer. It counts the characters in the string, stores that count in heap memory using malloc, and returns the address of that memory. The caller receives an int* — a pointer — not the value directly. To read the count, the caller must dereference with *result. To avoid a memory leak, the caller must call free(result) when finished.

What the function returns — address on heap, not the value itself

1
malloc: int *r = malloc(sizeof(int)) — allocates 4 bytes on the heap. Returns the address of those bytes.
2
Count loop: while(a[i] != '\0') i++ — walk the string until null terminator. i ends up as the length.
3
Write through pointer: *r = i — store the count into the heap memory via the pointer.
4
Return address: return r — caller receives the pointer (int*).
5
Caller reads: *result dereferences the pointer to get the count. free(result) releases the heap memory.

s2_fn_returns_ptr.c

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

/*  int *p(char *a)
    ─────────────────────────────────────────────────
    p is a FUNCTION
      takes   : char *a  (pointer to a string)
      returns : int*     (address of an integer)
    ─────────────────────────────────────────────────  */
int *getLength(char *a) {

    int *r = (int*)malloc(sizeof(int)); /* heap space for one int */

    int i = 0;
    while (a[i] != '\0') i++;    /* count characters       */

    *r = i;                       /* write count into heap  */
    return r;                     /* return the ADDRESS      */
}

int main() {
    char *word = "Password";     /* 8 characters           */

    int *result = getLength(word); /* result holds an ADDRESS */

    printf("Word     : %s\n",    word);
    printf("Address  : %p\n",    (void*)result);
    printf("Length   : %d\n",   *result); /* dereference to read */

    free(result);   /* release heap — always pair malloc with free */
    return 0;
}

output

Word     : Password
Address  : 0x55f3a2c1d010
Length   : 8

Why store in heap? A local variable inside getLength would vanish when the function returns. Heap memory (malloc) stays alive until you call free(). This is the reason functions that return a pointer must either use heap memory, a static variable, or a pointer to something the caller owns.

int (*p)(char *a) — p stores a function's address — call any matching function through it

Assign countVowels or countConsonants to the same pointer — call through p

Pointer to Function

int (*p)(char *a) declares p as a pointer — not a function. It stores the address of a function. Any function whose signature matches int someFunction(char *a) can be assigned to p. You call through p just like calling the function directly: p(text). The return value is a plain int — no pointer, no malloc, no free. The power: you can swap which function p points to at runtime.

p stores an address from code memory — two functions, one pointer

1
Declare the pointer: int (*p)(char *a); — p can hold the address of any function matching that signature.
2
Assign function 1: p = countVowels; — no parentheses, no call. Just the function name = its address.
3
Call through p: int v = p("Ananta"); — exactly like calling countVowels("Ananta") directly.
4
Reassign: p = countConsonants; — same pointer, different function. No int*, no malloc, no free.
5
Call again: int c = p("Ananta"); — now calls countConsonants. The value is a plain int on the stack.

s3_fn_pointer.c

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

/* Helper: check if char is a vowel */
int isVowel(char c) {
    return strchr("aeiouAEIOU", c) != NULL;
}

/*  First function — matches int (*p)(char *a)  */
int countVowels(char *a) {
    int count = 0;
    for (int i = 0; a[i] != '\0'; i++)
        if (isVowel(a[i])) count++;
    return count;         /* plain int — no pointer    */
}

/*  Second function — same signature, different task */
int countConsonants(char *a) {
    int count = 0;
    for (int i = 0; a[i] != '\0'; i++)
        if (a[i] != ' ' && !isVowel(a[i])) count++;
    return count;
}

int main() {
    char *word = "Ananta";

    /*  int (*p)(char *a)
        ─────────────────────────────────────────
        p is a POINTER to a function
          that takes : char *a
          that returns : int  (a plain value)
        ─────────────────────────────────────────  */
    int (*p)(char *a);          /* declare the pointer         */

    p = countVowels;            /* point p at countVowels      */
    printf("Vowels in '%s'     : %d\n", word, p(word));

    p = countConsonants;        /* re-point p — no malloc/free */
    printf("Consonants in '%s' : %d\n", word, p(word));

    return 0;
}

output

Vowels in 'Ananta'     : 3
Consonants in 'Ananta' : 3

Function name without () = its address. p = countVowels stores the address of countVowels in p. p = countVowels() with parentheses would call it and try to store the returned int into p — a type error. The parentheses make all the difference.

Complete Program — int *p(char *a) and int (*p)(char *a) side by side

Same string "Elephant" — function returns heap pointer — function pointer swaps tasks

Full Example

One string. Two completely different ways to use functions with char* parameters. getFirstCharCode matches int *p(char *a) — allocates heap memory and returns its address. countUpper and countLower both match int (*p)(char *a) — plain functions that return int values, assigned to the same pointer and called through it.

int *getFirstCharCode(char *a)

Takes string, stores ASCII of first char in heap int, returns its address.

Caller: int *r = getFirstCharCode(w);
Read: printf("%d", *r);
Release: free(r);

int (*p)(char *a)

Pointer that holds either countUpper or countLower.

Assign: p = countUpper;
Call: int n = p(word);
Swap: p = countLower; n = p(word);

s4_both_together.c

C — Complete Program

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

/* ═══════════════════════════════════════════════════
   Part A — matches:  int *p(char *a)
   p is a FUNCTION taking char*, returning int*
   stores ASCII code of first character on the heap
═══════════════════════════════════════════════════ */
int *getFirstCharCode(char *a) {
    int *r = (int*)malloc(sizeof(int));
    *r = (int)a[0];  /* a[0] is first char → cast to int = ASCII */
    return r;        /* return ADDRESS of heap int                */
}

/* ═══════════════════════════════════════════════════
   Part B — both match:  int (*p)(char *a)
   p is a POINTER to a function(char*)→int
   Two functions with the same signature
═══════════════════════════════════════════════════ */
int countUpper(char *a) {
    int n = 0;
    for (int i = 0; a[i] != '\0'; i++)
        if (a[i] >= 'A' && a[i] <= 'Z') n++;
    return n;
}

int countLower(char *a) {
    int n = 0;
    for (int i = 0; a[i] != '\0'; i++)
        if (a[i] >= 'a' && a[i] <= 'z') n++;
    return n;
}

int main() {
    char *word = "Elephant";

    printf("Word: %s\n\n", word);

    /* ── int *p(char *a) ────────────────────────────
       Call function, receive int* (address)          */
    int *code = getFirstCharCode(word);
    printf("int *getFirstCharCode:\n");
    printf("  First char  : '%c'\n", word[0]);
    printf("  Returned    : address %p\n", (void*)code);
    printf("  Value *code : %d  (ASCII of '%c')\n",
           *code, (char)*code);
    free(code);                  /* release heap memory    */

    printf("\n");

    /* ── int (*p)(char *a) ──────────────────────────
       Pointer holds function address, call through it */
    int (*p)(char *a);           /* declare function pointer */

    p = countUpper;              /* point at countUpper      */
    printf("int (*p)(char *a) = countUpper:\n");
    printf("  Uppercase letters : %d\n", p(word));

    p = countLower;              /* re-point at countLower   */
    printf("int (*p)(char *a) = countLower:\n");
    printf("  Lowercase letters : %d\n", p(word));

    return 0;
}

output

Word: Elephant

int *getFirstCharCode:
  First char  : 'E'
  Returned    : address 0x55a3b1c2d010
  Value *code : 69  (ASCII of 'E')

int (*p)(char *a) = countUpper:
  Uppercase letters : 1

int (*p)(char *a) = countLower:
  Lowercase letters : 7

"Elephant" breakdown: First char 'E' = ASCII 69. Uppercase: only E = 1. Lowercase: l e p h a n t = 7. The function pointer calls two completely different functions through the same p variable — no malloc, no free, just plain int values returned directly.

summary — every difference at a glance

📋

Everything Side by Side — The Complete Difference

Declaration · what p is · how to call · what you get back · memory

Reference

int *p(char *a)

p is: a function
Takes: char* (string pointer)
Returns: int* (memory address)
How to call: int *r = p(text);
To read value: *r
Memory: must free(r) if malloc used
Right side wins: (char*) before *
Example: int *getLength(char *a)

int (*p)(char *a)

p is: a pointer to a function
Takes: char* (passed through to fn)
Returns: int (plain value)
How to use: p = myFn; then p(text);
To read value: assign directly int v = p(text);
Memory: no free needed
Parens win: (*p) binds before (char*)
Example: int (*p)(char *a) = countVowels;

checklist

Reading rule: Start at p, go right first. (char *a) on the right → p is a function. (*p) parens lock pointer-ness first → p is a pointer to function.
int *p(char *a): p IS a function. Returns int* — an address. Caller dereferences with *result to get the value. Must free() if malloc was used inside.
int (*p)(char *a): p IS a pointer. Assign any matching function: p = myFn;. Call through it: int v = p(text);. Returns a plain int — no pointer, no free.
Assign vs call: p = countVowels (no parens) = store the address of countVowels. p = countVowels() (parens) = call the function and try to store its return value — a type mismatch.
heap vs stack: int *p(char *a) functions must use malloc so the returned address stays valid after the function returns. A local variable inside the function would die — its address would be dangling.
a[0] vs a: a is char* (an address). a[0] or *a is the actual first character. Cast the character: (int)a[0] → ASCII value. Cast the pointer: (int)a → memory address number (not useful).

Two Declarations —One Letter of Difference

Two Declarations —
One Letter of Difference