Pointer Fungsi di C: Sintaks, Callback, dan qsort

Kode yang sudah dikompilasi disimpan di memori sama seperti data, jadi sebuah fungsi punya alamat. Pointer fungsi adalah variabel yang menyimpan alamat itu, dan begitu kamu bisa menyimpan sebuah fungsi, kamu bisa mengirimnya sebagai argumen, menyimpan tabelnya, atau memilih di antaranya saat program berjalan.

Kemampuan itulah yang ada di balik pengurutan dengan urutan buatan sendiri, event handler, antarmuka plugin, dan state machine. Ini juga bagian sintaks C yang paling mungkin membuat pembaca berhenti dan memicingkan mata, jadi kita mulai dari situ.

Sintaks Deklarasi

Ambil sebuah fungsi biasa:

int add(int a, int b);

Untuk mendeklarasikan pointer yang bisa menyimpan alamatnya, ganti namanya dengan (*name):

int (*op)(int, int);

Bacalah dari dalam: op adalah pointer, ke sebuah fungsi, yang menerima (int, int), dan mengembalikan int.

Tanda kurung itu bukan hiasan. Tanpanya, * justru terikat ke tipe kembalian:

int (*f)(int);   // pointer to a function taking int, returning int
int *g(int);     // FUNCTION taking int, returning int* - completely different

Berikut contoh lengkap yang berjalan dari awal sampai akhir:

#include <stdio.h>

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; }

int main(void) {
    int (*op)(int, int);        // declare

    op = add;                   // assign (no & needed)
    printf("add:      %d\n", op(10, 3));

    op = subtract;              // point it somewhere else
    printf("subtract: %d\n", op(10, 3));

    op = &multiply;             // the & is allowed but redundant
    printf("multiply: %d\n", (*op)(10, 3));   // so is this call form

    printf("\nthe function itself lives at %p\n", (void *)(void (*)(void))add);
    return 0;
}

Kedua bentuk pemanggilan berfungsi karena nama fungsi otomatis dikonversi menjadi pointer. Tulis op(10, 3); penulisan (*op)(10, 3) adalah sisa gaya lama.

Satu catatan tentang printf terakhir itu: %p mengharapkan pointer objek, dan pointer fungsi secara formal adalah keluarga yang terpisah, jadi mencetaknya tidak sepenuhnya portabel. Cast itu membungkam compiler di platform di mana hal ini memang bisa dilakukan; kamu jarang sekali perlu mencetaknya.

typedef Membuatnya Mudah Dibaca

Sintaks deklarasinya cepat sekali jadi jelek, dan typedef adalah solusi standarnya:

#include <stdio.h>

typedef int (*BinaryOp)(int, int);   // BinaryOp = pointer to int(int,int)

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

// now a function taking a function reads like any other declaration
int apply(BinaryOp op, int x, int y) {
    return op(x, y);
}

int main(void) {
    BinaryOp op = add;
    printf("apply(add, 4, 5)      = %d\n", apply(op, 4, 5));
    printf("apply(multiply, 4, 5) = %d\n", apply(multiply, 4, 5));
    return 0;
}

Bandingkan int apply(BinaryOp op, int x, int y) dengan bentuk mentahnya, int apply(int (*op)(int, int), int x, int y). Artinya sama; yang satu bisa kamu baca sekilas. Lihat typedef untuk aturan umumnya.

Callback: Membiarkan Pemanggil Menentukan Perilaku

Callback adalah fungsi yang kamu serahkan ke fungsi lain agar ia bisa memanggilmu kembali di saat yang tepat. Dengan callback, satu bagian kode mengurus struktur pekerjaannya sementara pemanggil menentukan keputusannya.

#include <stdio.h>

typedef int (*Predicate)(int);

int is_even(int n)     { return n % 2 == 0; }
int is_positive(int n) { return n > 0; }
int is_big(int n)      { return n > 100; }

// one function, any test
int count_if(const int *arr, int n, Predicate test) {
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (test(arr[i])) {
            count++;
        }
    }
    return count;
}

int main(void) {
    int data[8] = {-4, 3, 120, 7, -9, 200, 0, 15};
    int n = 8;

    printf("even:     %d\n", count_if(data, n, is_even));
    printf("positive: %d\n", count_if(data, n, is_positive));
    printf("big:      %d\n", count_if(data, n, is_big));

    return 0;
}

Tanpa pointer fungsi, kamu akan menulis count_even, count_positive, dan count_big, yaitu tiga salinan dari loop yang sama. Dengan pointer fungsi, loop-nya ditulis sekali dan pengujiannya yang menjadi parameter.

Manfaat Sebenarnya: qsort

qsort dari library standar adalah contoh pointer fungsi yang benar-benar akan kamu pakai. Fungsi ini mengurutkan array berisi apa saja, dan bisa melakukannya tanpa tahu apa pun tentang elemennya selain ukurannya dan comparator yang kamu berikan.

void qsort(void *base, size_t nmemb, size_t size,
           int (*compar)(const void *, const void *));

Comparator menerima dua const void *, yaitu alamat dua elemen, dan mengembalikan angka negatif kalau elemen pertama diurutkan sebelum elemen kedua, nol kalau keduanya setara, dan positif kalau elemen pertama diurutkan sesudahnya.

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

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;      // cast back to the real type, then read
    int y = *(const int *)b;
    if (x < y) return -1;
    if (x > y) return  1;
    return 0;
}

int compare_desc(const void *a, const void *b) {
    return compare_ints(b, a);    // swap the arguments to reverse the order
}

int main(void) {
    int data[8] = {42, 7, 19, 3, 88, 1, 55, 23};
    int n = sizeof data / sizeof data[0];

    qsort(data, n, sizeof data[0], compare_ints);
    printf("ascending:  ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);

    qsort(data, n, sizeof data[0], compare_desc);
    printf("\ndescending: ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);
    printf("\n");

    return 0;
}

Ada dua kebiasaan yang perlu dibawa dari comparator itu. Jangan pernah menulis return x - y;: kelihatannya cerdik, tetapi overflow untuk nilai yang besar atau negatif, sehingga tandanya salah dan array-nya tidak terurut dengan benar. Lakukan cast sebelum dereference, bukan sesudahnya: *(const int *)a, karena *a pada void * tidak punya apa-apa untuk dibaca.

Mekanisme yang sama bisa mengurutkan struct berdasarkan field apa pun yang kamu mau:

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

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

int by_score(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return (q->score > p->score) - (q->score < p->score);   // highest first
}

int by_name(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return strcmp(p->name, q->name);
}

int main(void) {
    Player players[4] = {
        {"Ada",   91},
        {"Grace", 78},
        {"Linus", 91},
        {"Ken",   85}
    };
    int n = 4;

    qsort(players, n, sizeof players[0], by_score);
    printf("by score:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    qsort(players, n, sizeof players[0], by_name);
    printf("by name:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    return 0;
}

Pola (q->score > p->score) - (q->score < p->score) mengembalikan tepat -1, 0, atau 1 tanpa pengurangan dan tanpa overflow. Lalu strcmp sudah punya konvensi nilai kembalian yang tepat, jadi comparator untuk string cukup satu baris.

Tabel Pointer Fungsi

Array berisi pointer fungsi mengubah rantai if/else menjadi pencarian di tabel. Begitulah cara interpreter men-dispatch opcode dan cara sistem menu menjalankan perintah.

#include <stdio.h>

typedef double (*Operation)(double, double);

double op_add(double a, double b) { return a + b; }
double op_sub(double a, double b) { return a - b; }
double op_mul(double a, double b) { return a * b; }
double op_div(double a, double b) { return b == 0 ? 0.0 : a / b; }

typedef struct {
    char      symbol;
    Operation fn;
    const char *name;
} Entry;

int main(void) {
    Entry table[] = {
        {'+', op_add, "add"},
        {'-', op_sub, "subtract"},
        {'*', op_mul, "multiply"},
        {'/', op_div, "divide"}
    };
    int n = sizeof table / sizeof table[0];

    double x = 12.0, y = 4.0;

    for (int i = 0; i < n; i++) {
        printf("%.1f %c %.1f = %.2f   (%s)\n",
               x, table[i].symbol, y, table[i].fn(x, y), table[i].name);
    }

    // dispatch on a character, without a switch
    char wanted = '*';
    for (int i = 0; i < n; i++) {
        if (table[i].symbol == wanted) {
            printf("\ndispatched '%c' -> %.2f\n", wanted, table[i].fn(x, y));
            break;
        }
    }

    return 0;
}

Menambah operasi sekarang berarti menambah satu baris, bukan mengedit switch. Gabungkan dengan struct dan kamu mendapat bentuk plugin C yang standar: struct berisi pointer fungsi adalah arti "interface" di bahasa ini.

Hal-Hal yang Menjebak

Signature harus cocok persis. Tipe pointer fungsi mencakup tipe parameter dan tipe kembaliannya. Meng-assign fungsi yang tidak cocok adalah pelanggaran batasan, dan memanggil lewat pointer dengan tipe yang salah adalah undefined behavior bahkan saat terlihat "berfungsi". Jangan melakukan cast pada signature comparator demi membungkam peringatan; perbaiki comparator-nya.

Pointer fungsi yang null tetaplah null pointer. Inisialisasi dengan NULL dan periksa sebelum memanggil, persis seperti pointer data:

if (handler != NULL) {
    handler(event);
}

Lihat null pointer untuk alasan pemeriksaan itu layak dilakukan.

Pointer void kehilangan keamanan tipe, dan kamulah sistem tipenya. Di dalam comparator qsort, tidak ada yang mencegahmu melakukan cast ke tipe yang salah. Kalau kamu mengurutkan array double dengan compare_ints, kodenya bisa dikompilasi tanpa masalah tetapi hasilnya ngawur.

Sintaks deklaratornya bisa bersarang. Fungsi yang mengembalikan pointer fungsi ditulis int (*get_op(char c))(int, int);. Saat kamu mendapati dirimu menulis itu, pakai typedef:

typedef int (*BinaryOp)(int, int);
BinaryOp get_op(char c);           // the same thing, readable