C function pointer และ callback



ฟังก์ชันก็อยู่ในหน่วยความจำ มีที่อยู่ — เก็บที่อยู่นั้นใน pointer แล้วส่งต่อ/เรียกทีหลังได้

ประกาศและใช้

#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);       // op = pointer ไปฟังก์ชันที่รับ (int,int) คืน int

    op = add;                  // ชื่อฟังก์ชัน = ที่อยู่ (ไม่ต้องมี &)
    printf("%d\n", op(3, 4));  // 7  (เรียกผ่าน pointer เหมือนเรียกฟังก์ชันปกติ)

    op = multiply;
    printf("%d\n", op(3, 4));  // 12

    op = &subtract;            // & ก็ได้ ผลเหมือนกัน
    printf("%d\n", (*op)(10, 3));  // 7  — (*op)(...) ก็ได้ ผลเหมือนกัน
    return 0;
}

การประกาศ int (*op)(int, int):

  • op — ชื่อตัวแปร
  • (*op) — เป็น pointer (วงเล็บจำเป็น! int *op(int,int) = ฟังก์ชันที่คืน int *)
  • (int, int) — พารามิเตอร์
  • int ข้างหน้า — return type

typedef ช่วยให้อ่านง่าย

typedef int (*BinaryOp)(int, int);

BinaryOp op = add;
printf("%d\n", op(5, 6));

void apply(BinaryOp fn, int x, int y)
{
    printf("ผลลัพธ์: %d\n", fn(x, y));
}
apply(multiply, 4, 5);      // 20

ส่งฟังก์ชันเป็น argument — callback

#include <stdio.h>

// รับ pointer ไปฟังก์ชันที่จะเรียกกับแต่ละสมาชิก
void for_each(const int *arr, size_t n, void (*visit)(int))
{
    for (size_t i = 0; i < n; i++) {
        visit(arr[i]);
    }
}

void print_num(int x)        { printf("%d ", x); }
void print_square(int x)     { printf("%d ", x * x); }

int main(void)
{
    int data[] = {1, 2, 3, 4, 5};

    for_each(data, 5, print_num);      // 1 2 3 4 5
    printf("\n");
    for_each(data, 5, print_square);   // 1 4 9 16 25
    printf("\n");
    return 0;
}

for_each ไม่รู้ว่าจะทำอะไรกับแต่ละตัว — ผู้เรียกบอกผ่าน callback

qsort — ตัวอย่างจริงจาก stdlib

qsort เรียงอาร์เรย์อะไรก็ได้ โดยเรารับผิดชอบ comparator ที่บอกว่าสองตัวไหนมาก่อน

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

int compare_int_asc(const void *a, const void *b)
{
    int x = *(const int *)a;      // cast void* กลับเป็น int* แล้ว deref
    int y = *(const int *)b;
    return (x > y) - (x < y);     // -1, 0, 1  (อย่าใช้ x - y — overflow ได้)
}

int main(void)
{
    int nums[] = {5, 2, 8, 1, 9, 3};
    size_t n = sizeof(nums) / sizeof(nums[0]);

    qsort(nums, n, sizeof(nums[0]), compare_int_asc);

    for (size_t i = 0; i < n; i++) printf("%d ", nums[i]);   // 1 2 3 5 8 9
    printf("\n");
    return 0;
}

comparator ต้องมีลายเซ็น int (*)(const void *, const void *) และคืน:

  • < 0 ถ้า a มาก่อน b
  • 0 ถ้าเท่ากัน
  • > 0 ถ้า a มาหลัง b

เรียง struct:

typedef struct { char name[20]; int age; } Person;

int by_age(const void *a, const void *b)
{
    const Person *pa = a, *pb = b;
    return (pa->age > pb->age) - (pa->age < pb->age);
}

Person people[3] = {{"อร", 30}, {"บอย", 25}, {"แก้ว", 28}};
qsort(people, 3, sizeof(Person), by_age);

bsearch (ค้นหาแบบ binary) ใช้ comparator แบบเดียวกัน

dispatch table — แทน switch ยาว ๆ

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

typedef struct {
    const char *name;
    void (*handler)(void);
} Command;

void cmd_help(void)    { printf("แสดงความช่วยเหลือ\n"); }
void cmd_version(void) { printf("เวอร์ชัน 1.0\n"); }
void cmd_list(void)    { printf("รายการทั้งหมด\n"); }

static const Command commands[] = {
    {"help",    cmd_help},
    {"version", cmd_version},
    {"list",    cmd_list},
};

void run_command(const char *name)
{
    for (size_t i = 0; i < sizeof(commands) / sizeof(commands[0]); i++) {
        if (strcmp(commands[i].name, name) == 0) {
            commands[i].handler();
            return;
        }
    }
    printf("ไม่รู้จักคำสั่ง: %s\n", name);
}

int main(void)
{
    run_command("version");
    run_command("list");
    run_command("xyz");
    return 0;
}

เพิ่มคำสั่งใหม่ = เพิ่มแถวในตาราง ไม่ต้องแก้ run_command — ใช้ในตัว interpreter, HTTP router, state machine

array of function pointers

typedef int (*Operation)(int, int);

Operation ops[] = {add, subtract, multiply};
const char *names[] = {"+", "-", "*"};

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

เรื่องที่คนมักพลาด

  • ลืมวงเล็บรอบ * — int *fp(int) คือฟังก์ชันคืน int *, ต้อง int (*fp)(int)
  • comparator ของ qsort ลายเซ็นผิด — ต้องเป็น int (*)(const void *, const void *) เป๊ะ
  • cast void * ผิดชนิดใน comparator — *(int *)a เมื่อจริง ๆ เป็น double
  • return x - y ใน comparator — overflow ถ้า x, y ห่างกันมาก ใช้ (x > y) - (x < y)
  • เก็บ pointer ไปฟังก์ชัน local — C ไม่มี nested function (มาตรฐาน) ฟังก์ชันเป็น global เสมอ ไม่มีปัญหา dangling
  • qsort ไม่ stable — สมาชิกที่เท่ากันอาจสลับลำดับ ถ้าต้องการ stable ต้องเขียนเอง
  • เรียก function pointer ที่เป็น NULL — crash เช็คก่อนถ้าอาจ NULL

สรุป

  • int (*fp)(int, int) — pointer ไปฟังก์ชัน; fp = add; (ชื่อฟังก์ชัน = ที่อยู่), เรียก fp(a, b)
  • typedef int (*BinaryOp)(int, int); ทำให้อ่านง่าย
  • callback: ส่ง function pointer เป็น argument ให้ฟังก์ชันทั่วไปทำงานเฉพาะทางได้ (for_each, qsort)
  • qsort(arr, n, size, cmp) — cmp คืน <0 / 0 / >0, ใช้ (x>y)-(x<y) เลี่ยง overflow
  • dispatch table (array of {name, handler}) แทน switch/if ยาว — เพิ่มคำสั่งง่าย

จบเฟส struct/data structures บทถัดไปเข้าเฟสไฟล์ I/O เริ่มที่ fopen / fclose / fprintf / fscanf