Function Pointers

#include <stdio.h>

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

/* Function that accepts a function pointer as a parameter */
int apply(int (*fn)(int, int), int x, int y) {
    return fn(x, y);   /* call through the pointer */
}

int main(void) {
    /* Declare a function pointer variable */
    int (*op)(int, int);

    op = add;                          /* assign — function name decays */
    printf("add: %d\n", op(3, 4));     /* call: 7 */

    op = mul;
    printf("mul: %d\n", op(3, 4));     /* call: 12 */

    /* Pass function pointer to another function */
    printf("apply(add,5,6): %d\n", apply(add, 5, 6));  /* 11 */
    printf("apply(mul,5,6): %d\n", apply(mul, 5, 6));  /* 30 */

    return 0;
}

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

/* Comparison function: must match qsort's expected signature */
/* Returns negative/0/positive for less-than/equal/greater-than */
int cmp_int(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    return x - y;   /* ascending order */
}

int cmp_int_desc(const void *a, const void *b) {
    return *(const int *)b - *(const int *)a;  /* descending */
}

int main(void) {
    int arr[] = {5, 2, 8, 1, 9, 3};
    int n = 6;

    /* qsort(array, count, element_size, compare_fn) */
    qsort(arr, n, sizeof(int), cmp_int);

    printf("Ascending:  ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");

    qsort(arr, n, sizeof(int), cmp_int_desc);

    printf("Descending: ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");

    return 0;
}

#include <stdio.h>

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

/* typedef makes the array declaration readable */
typedef int (*bin_op)(int, int);

int main(void) {
    /* Array of 3 function pointers */
    bin_op ops[3] = { add, sub, mul };
    const char *names[] = { "add", "sub", "mul" };

    int a = 10, b = 3;
    for (int i = 0; i < 3; i++) {
        printf("%s(%d, %d) = %d\n", names[i], a, b, ops[i](a, b));
    }

    /* Select operation at runtime (e.g. from user input) */
    int choice = 1;   /* could come from scanf */
    printf("Choice %d: %d\n", choice, ops[choice](a, b));

    return 0;
}

#include <stdio.h>

/* From lecture: typedef int (*quack_f)(int); */
typedef int (*quack_f)(int);

int loud_quack(int n) {
    for (int i = 0; i < n; i++) printf("QUACK! ");
    printf("\n");
    return n;
}

int soft_quack(int n) {
    for (int i = 0; i < n; i++) printf("quack ");
    printf("\n");
    return n;
}

/* A "duck" struct uses a function pointer for behaviour */
typedef struct {
    const char *name;
    quack_f quack;   /* behaviour injected via function pointer */
} Duck;

int main(void) {
    Duck d1 = { "Mallard", loud_quack };
    Duck d2 = { "Rubber",  soft_quack };

    printf("%s: ", d1.name); d1.quack(3);
    printf("%s: ", d2.name); d2.quack(2);

    return 0;
}

#include <stdlib.h>
#include <math.h>

struct duck {
    float position[1];          /* duck's current x-position (array of 1 float) */
    float velocity[1];          /* current velocity: positive=right, negative=left */
    struct duck *duck_in_front; /* next duck in the queue (NULL if none ahead) */
    int (*quack)(int);          /* function pointer: takes int, returns int */
    int alive;                  /* 1 = alive, 0 = dead */
};

int same_direction(struct duck *a, struct duck *b) {
    /* velocity[0] because position and velocity are arrays of 1 element */
    if (a->velocity[0] == 0.0f || b->velocity[0] == 0.0f) return 1;
    /* same sign = same direction */
    return (a->velocity[0] > 0 && b->velocity[0] > 0) ||
           (a->velocity[0] < 0 && b->velocity[0] < 0);
}

void update_position(struct duck *d) {
    /* Part 2: add velocity to position */
    d->position[0] += d->velocity[0];

    /* Part 2: if no duck in front, we are done */
    if (d->duck_in_front == NULL) return;

    /* Part 5: if duck_in_front is dead, replace it with a new dead duck */
    if (!d->duck_in_front->alive) {
        struct duck *dead = malloc(sizeof(struct duck));
        dead->alive = 0;
        dead->duck_in_front = NULL;
        d->duck_in_front = dead;
        return;  /* done after replacing */
    }

    /* Part 3: signed distance (front minus self) */
    float dist = d->duck_in_front->position[0] - d->position[0];
    if (fabs(dist) < 1.0f) {
        /* too close — stop */
        d->velocity[0] = 0.0f;
        return;
    }

    /* Part 4: if d has overtaken duck_in_front, swap the queue order */
    if (d->position[0] > d->duck_in_front->position[0]) {
        struct duck *tmp = d->duck_in_front;
        d->duck_in_front = NULL;   /* d is now at the front */
        tmp->duck_in_front = d;    /* the overtaken duck is now behind d */
        d->quack(1);               /* announce the overtake via function pointer */
    }
}