Function Pointers in C Explained — Syntax, Callbacks, and Real-World Patterns

#include <stdio.h>

// Three simple math operations — all share the same signature: (int, int) -> int
int add(int a, int b)      { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }

// typedef gives the function pointer type a readable name.
// Read as: MathOperation is a pointer to a function taking two ints, returning int.
typedef int (*MathOperation)(int, int);

int main(void) {
    // Declare a function pointer and assign it — no & needed, function name decays to its address
    MathOperation operation = add;

    printf("add(10, 4)      = %d\n", operation(10, 4));  // calls add via pointer

    operation = subtract;                                  // reassign — now points to subtract
    printf("subtract(10, 4) = %d\n", operation(10, 4));

    operation = multiply;                                  // reassign again
    printf("multiply(10, 4) = %d\n", operation(10, 4));

    // You can also use the explicit dereference form — identical behaviour
    MathOperation explicit_op = add;
    printf("(*explicit_op)(10, 4) = %d\n", (*explicit_op)(10, 4));

    return 0;
}

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

// --- Part 1: Building a custom qsort comparator ---

typedef struct {
    char name[32];
    int  score;
} Player;

// Comparator for ascending score order.
// qsort passes void* pointers — we cast them to the type we know they are.
int compare_score_ascending(const void *a, const void *b) {
    const Player *player_a = (const Player *)a;
    const Player *player_b = (const Player *)b;
    return player_a->score - player_b->score;  // negative = a comes first
}

// Comparator for descending score order — just flip the subtraction
int compare_score_descending(const void *a, const void *b) {
    const Player *player_a = (const Player *)a;
    const Player *player_b = (const Player *)b;
    return player_b->score - player_a->score;
}

// --- Part 2: Our own callback-based filter function ---

typedef int (*PlayerPredicate)(const Player *player);

// Calls predicate on every player; prints those for which predicate returns non-zero.
// The caller decides the filter rule — this function stays generic.
void print_filtered_players(const Player *players, int count, PlayerPredicate predicate) {
    for (int i = 0; i < count; i++) {
        if (predicate(&players[i])) {           // callback invoked here
            printf("  %-15s %d\n", players[i].name, players[i].score);
        }
    }
}

// Two different filter predicates — same signature, different logic
int is_high_scorer(const Player *player) { return player->score >= 80; }
int is_low_scorer(const Player *player)  { return player->score < 50; }

int main(void) {
    Player players[] = {
        {"Alice",   92},
        {"Bob",     45},
        {"Charlie", 78},
        {"Diana",   33},
        {"Eve",     88}
    };
    int count = sizeof(players) / sizeof(players[0]);

    // Sort ascending using qsort + our comparator callback
    qsort(players, count, sizeof(Player), compare_score_ascending);
    printf("Sorted ascending by score:\n");
    for (int i = 0; i < count; i++) {
        printf("  %-15s %d\n", players[i].name, players[i].score);
    }

    // Sort descending — swap the callback, everything else stays the same
    qsort(players, count, sizeof(Player), compare_score_descending);
    printf("\nSorted descending by score:\n");
    for (int i = 0; i < count; i++) {
        printf("  %-15s %d\n", players[i].name, players[i].score);
    }

    // Use our custom filter with two different predicate callbacks
    printf("\nHigh scorers (>= 80):\n");
    print_filtered_players(players, count, is_high_scorer);  // passes predicate

    printf("\nLow scorers (< 50):\n");
    print_filtered_players(players, count, is_low_scorer);   // different predicate, same function

    return 0;
}

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

// --- A tiny command dispatcher using a dispatch table ---

// All command handler functions share this signature
typedef void (*CommandHandler)(const char *argument);

// The actual command implementations
void handle_hello(const char *argument) {
    printf("Hello, %s!\n", argument[0] ? argument : "world");
}

void handle_shout(const char *argument) {
    // Print the argument in uppercase-style by prepending SHOUT:
    printf("SHOUT: ");
    for (int i = 0; argument[i] != '\0'; i++) {
        // Convert lowercase letters to uppercase manually
        char c = argument[i];
        if (c >= 'a' && c <= 'z') c -= 32;
        putchar(c);
    }
    putchar('\n');
}

void handle_count(const char *argument) {
    int length = 0;
    while (argument[length] != '\0') length++;
    printf("'%s' has %d characters.\n", argument, length);
}

void handle_reverse(const char *argument) {
    int length = 0;
    while (argument[length] != '\0') length++;
    printf("Reversed: ");
    for (int i = length - 1; i >= 0; i--) putchar(argument[i]);
    putchar('\n');
}

// --- The dispatch table itself ---
// A struct pairs a command name with its handler — clean and extensible.
typedef struct {
    const char    *command_name;
    CommandHandler handler;          // function pointer stored inside a struct
} DispatchEntry;

// Adding a new command = adding one row here. The dispatcher never changes.
static const DispatchEntry dispatch_table[] = {
    { "hello",   handle_hello   },
    { "shout",   handle_shout   },
    { "count",   handle_count   },
    { "reverse", handle_reverse },
};

// Calculate table size at compile time — avoids magic numbers
static const int TABLE_SIZE = sizeof(dispatch_table) / sizeof(dispatch_table[0]);

// The dispatcher: walks the table, finds the matching entry, calls the handler.
void dispatch(const char *command, const char *argument) {
    for (int i = 0; i < TABLE_SIZE; i++) {
        if (strcmp(dispatch_table[i].command_name, command) == 0) {
            dispatch_table[i].handler(argument);  // function pointer call
            return;
        }
    }
    printf("Unknown command: '%s'\n", command);
}

int main(void) {
    dispatch("hello",   "Alice");
    dispatch("shout",   "make some noise");
    dispatch("count",   "function pointers");
    dispatch("reverse", "dispatch");
    dispatch("quit",    "");   // not in the table — triggers unknown-command path

    return 0;
}

#include <stdio.h>
#include <math.h>

// --- Runtime polymorphism in C using function pointers in structs ---

// Forward declaration — Shape needs to refer to itself
typedef struct Shape Shape;

// A 'virtual function table': a struct of function pointers.
// Every Shape type provides its own implementation of these.
typedef struct {
    double (*area)(const Shape *self);      // how to compute this shape's area
    double (*perimeter)(const Shape *self); // how to compute its perimeter
    void   (*describe)(const Shape *self);  // how to print a description
} ShapeOps;

// The base Shape struct: holds a pointer to its ops table and shared data.
struct Shape {
    const ShapeOps *ops;   // pointer to the function table — this IS the polymorphism
    const char     *label; // a human-readable name for printing
};

// --- Circle implementation ---
typedef struct {
    Shape  base;   // MUST be first — allows safe casting between Shape* and Circle*
    double radius;
} Circle;

double circle_area(const Shape *self) {
    const Circle *circle = (const Circle *)self;  // safe: base is first member
    return M_PI * circle->radius * circle->radius;
}
double circle_perimeter(const Shape *self) {
    const Circle *circle = (const Circle *)self;
    return 2.0 * M_PI * circle->radius;
}
void circle_describe(const Shape *self) {
    const Circle *circle = (const Circle *)self;
    printf("Circle (radius=%.2f)\n", circle->radius);
}

// The ops table for circles — one shared instance for all circles
static const ShapeOps CIRCLE_OPS = {
    circle_area, circle_perimeter, circle_describe
};

void circle_init(Circle *circle, double radius) {
    circle->base.ops   = &CIRCLE_OPS;  // wire up the function table
    circle->base.label = "circle";
    circle->radius     = radius;
}

// --- Rectangle implementation ---
typedef struct {
    Shape  base;
    double width;
    double height;
} Rectangle;

double rect_area(const Shape *self) {
    const Rectangle *rect = (const Rectangle *)self;
    return rect->width * rect->height;
}
double rect_perimeter(const Shape *self) {
    const Rectangle *rect = (const Rectangle *)self;
    return 2.0 * (rect->width + rect->height);
}
void rect_describe(const Shape *self) {
    const Rectangle *rect = (const Rectangle *)self;
    printf("Rectangle (%.2f x %.2f)\n", rect->width, rect->height);
}

static const ShapeOps RECT_OPS = {
    rect_area, rect_perimeter, rect_describe
};

void rect_init(Rectangle *rect, double width, double height) {
    rect->base.ops   = &RECT_OPS;
    rect->base.label = "rectangle";
    rect->width      = width;
    rect->height     = height;
}

// --- Generic function that works on ANY Shape ---
// It never knows if it has a circle or rectangle — it just calls through the ops pointer.
void print_shape_stats(const Shape *shape) {
    shape->ops->describe(shape);                         // polymorphic call
    printf("  Area:      %.4f\n", shape->ops->area(shape));
    printf("  Perimeter: %.4f\n", shape->ops->perimeter(shape));
}

int main(void) {
    Circle    c;  rect_init(NULL, 0, 0);  // just declarations
    Rectangle r;

    circle_init(&c, 5.0);
    rect_init(&r, 4.0, 6.0);

    // An array of base Shape pointers — holds mixed types
    const Shape *shapes[] = { (Shape *)&c, (Shape *)&r };
    int shape_count = sizeof(shapes) / sizeof(shapes[0]);

    for (int i = 0; i < shape_count; i++) {
        print_shape_stats(shapes[i]);  // same call, different behavior
        printf("\n");
    }

    return 0;
}