Con trỏ hàm trong C: cú pháp, callback và qsort

Code đã biên dịch nằm trong bộ nhớ giống như dữ liệu, nên hàm cũng có địa chỉ. Con trỏ hàm (function pointer) là một biến lưu địa chỉ đó, và khi đã lưu được một hàm, bạn có thể truyền nó làm đối số, giữ cả một bảng các hàm, hoặc chọn hàm nào để chạy lúc chương trình đang thực thi.

Đó là khả năng đứng sau việc sắp xếp theo thứ tự tùy chỉnh, trình xử lý sự kiện, giao diện plugin và máy trạng thái. Đây cũng là phần cú pháp C dễ khiến người đọc phải dừng lại nheo mắt nhất, nên ta bắt đầu từ đó.

Cú pháp khai báo

Lấy một hàm bình thường:

int add(int a, int b);

Để khai báo một con trỏ chứa được địa chỉ của nó, thay tên hàm bằng (*name):

int (*op)(int, int);

Đọc từ trong ra: op là một con trỏ, tới một hàm, nhận (int, int), trả về int.

Cặp ngoặc không phải để trang trí. Thiếu chúng, * sẽ gắn vào kiểu trả về:

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

Đây là ví dụ chạy trọn vẹn:

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

Cả hai cách gọi đều chạy được vì tên hàm tự động chuyển thành con trỏ. Hãy viết op(10, 3); cách viết (*op)(10, 3) là thói quen còn sót lại.

Một lưu ý về lệnh printf cuối: %p cần một con trỏ đối tượng, còn con trỏ hàm về mặt hình thức thuộc một nhóm riêng, nên in nó ra không hoàn toàn khả chuyển. Phép ép kiểu giúp trình biên dịch im lặng trên những nền tảng mà việc này chạy được; hiếm khi bạn cần in một con trỏ hàm.

typedef giúp code dễ đọc

Cú pháp khai báo nhanh chóng trở nên rối mắt, và typedef là cách chữa tiêu chuẩn:

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

So sánh int apply(BinaryOp op, int x, int y) với dạng gốc int apply(int (*op)(int, int), int x, int y). Nghĩa như nhau, nhưng chỉ một trong hai đọc được ngay. Xem trang typedef để biết các quy tắc chung.

Callback: để bên gọi tự quyết định hành vi

Callback là một hàm bạn đưa cho hàm khác để nó gọi lại bạn vào đúng thời điểm. Nhờ đó một đoạn code lo phần khung của công việc, còn bên gọi cung cấp phần quyết định.

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

Không có con trỏ hàm, bạn sẽ phải viết count_even, count_positive và count_big, ba bản sao của cùng một vòng lặp. Có con trỏ hàm, vòng lặp chỉ viết một lần và phép kiểm tra trở thành tham số.

Lợi ích thật sự: qsort

Hàm qsort của thư viện chuẩn là ví dụ con trỏ hàm mà bạn sẽ thật sự dùng. Nó sắp xếp mảng thuộc bất kỳ kiểu nào, và làm được vậy là nhờ không cần biết gì về các phần tử ngoài kích thước của chúng và một hàm so sánh do bạn cung cấp.

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

Hàm so sánh nhận hai const void *, tức địa chỉ của hai phần tử, và trả về số âm nếu phần tử đầu đứng trước phần tử sau, 0 nếu bằng nhau, số dương nếu đứng sau.

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

Có hai thói quen nên rút ra từ hàm so sánh này. Đừng bao giờ viết return x - y;: trông thì gọn nhưng sẽ tràn số với giá trị lớn hoặc âm, cho ra dấu sai và mảng bị sắp xếp sai. Ép kiểu trước khi dereference, không phải sau: *(const int *)a, vì *a trên một void * không có gì để đọc.

Cùng cơ chế đó sắp xếp struct theo bất kỳ trường nào bạn muốn:

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

Thành ngữ (q->score > p->score) - (q->score < p->score) trả về đúng -1, 0 hoặc 1 mà không có phép trừ nào và không tràn số. Còn strcmp vốn đã có quy ước trả về phù hợp, nên hàm so sánh chuỗi chỉ cần một dòng.

Bảng con trỏ hàm

Một mảng con trỏ hàm biến chuỗi if/else thành một phép tra cứu. Đây là cách các trình thông dịch điều phối opcode và cách các hệ thống menu chạy lệnh.

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

Giờ thêm một phép toán chỉ là thêm một hàng, không phải sửa switch. Kết hợp với struct là bạn có dạng plugin chuẩn của C: một struct chứa các con trỏ hàm chính là "interface" trong ngôn ngữ này.

Những chỗ dễ vấp

Chữ ký phải khớp chính xác. Kiểu của con trỏ hàm bao gồm kiểu các tham số và kiểu trả về. Gán một hàm không khớp là vi phạm ràng buộc, và gọi hàm qua một con trỏ sai kiểu là undefined behavior kể cả khi nó "chạy được". Đừng ép kiểu chữ ký của hàm so sánh để tắt cảnh báo: hãy sửa hàm so sánh.

Con trỏ hàm null vẫn là con trỏ null. Khởi tạo bằng NULL và kiểm tra trước khi gọi, y như với con trỏ dữ liệu:

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

Xem con trỏ null để hiểu vì sao phép kiểm tra đó đáng giá.

Con trỏ void làm mất an toàn kiểu, và bạn chính là hệ thống kiểu. Bên trong hàm so sánh của qsort, không gì ngăn bạn ép sang sai kiểu. Nếu bạn sắp xếp một mảng double bằng compare_ints, code vẫn biên dịch trơn tru và cho ra kết quả vô nghĩa.

Cú pháp khai báo có thể lồng nhau. Một hàm trả về con trỏ hàm được viết là int (*get_op(char c))(int, int);. Khi thấy mình phải viết như vậy, hãy dùng typedef:

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