C言語の関数ポインタ：構文、コールバック、qsort

コンパイルされたコードもデータと同じくメモリに置かれるので、関数にはアドレスがあります。関数ポインタはそれを格納する変数です - そして関数を格納できるようになれば、それを引数として渡したり、テーブルに並べたり、実行時に選んだりできます。

それが、独自の順序でのソート、イベントハンドラ、プラグインのインターフェース、状態機械を支える能力です。同時に、読み手が思わず目を細めるC言語の構文の筆頭でもあるので、そこから始めましょう。

宣言の構文

普通の関数を用意します。

int add(int a, int b);

そのアドレスを保持できるポインタを宣言するには、名前を (*名前) に置き換えます。

int (*op)(int, int);

内側から読みましょう。op はポインタで、(int, int) を取り int を返す関数へのポインタです。

かっこは飾りではありません。なければ * は代わりに戻り値の型に結び付きます。

int (*f)(int);   // int を取り int を返す関数へのポインタ
int *g(int);     // int を取り int* を返す「関数」 - まったくの別物

端から端まで動かすとこうなります。

#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 = add;                   // 代入（& は不要）
    printf("add:      %d\n", op(10, 3));

    op = subtract;              // 別のところを指させる
    printf("subtract: %d\n", op(10, 3));

    op = &multiply;             // & は許されるが冗長
    printf("multiply: %d\n", (*op)(10, 3));   // この呼び出し形式も同様

    printf("\n関数そのものは %p にある\n", (void *)(void (*)(void))add);
    return 0;
}

どちらの呼び出し形式も動くのは、関数指示子が自動的にポインタへ変換されるからです。op(10, 3) と書きましょう。(*op)(10, 3) という綴りは名残です。

最後の printf について一言。%p はオブジェクトへのポインタを期待し、関数ポインタは形式上は別の系統なので、それを表示するのは厳密には移植性がありません。このキャストは、そもそも動くプラットフォームでコンパイラを黙らせるためのものです。関数ポインタを表示する機会はまずないでしょう。

typedef で読みやすくする

宣言の構文はすぐに醜くなり、typedef が定石の処方箋です。

#include <stdio.h>

typedef int (*BinaryOp)(int, int);   // BinaryOp = int(int,int) へのポインタ

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

// 関数を取る関数が、ほかの宣言と同じように読める
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;
}

int apply(BinaryOp op, int x, int y) を、生の形 int apply(int (*op)(int, int), int x, int y) と比べてみてください。意味は同じですが、一目で読めるのは一方だけです。一般的な規則は typedef を見てください。

コールバック：振る舞いを呼び出し側に決めさせる

コールバックとは、適切な瞬間に呼び返してもらうために別の関数へ手渡す関数のことです。これにより、仕事の骨組みを1つのコードが受け持ち、判断は呼び出し側が与える、という分担ができます。

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

// 1つの関数で、どんな判定にも対応する
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("偶数:   %d\n", count_if(data, n, is_even));
    printf("正の数: %d\n", count_if(data, n, is_positive));
    printf("大きい: %d\n", count_if(data, n, is_big));

    return 0;
}

関数ポインタがなければ、count_even、count_positive、count_big と、同じループのコピーを3つ書くことになります。関数ポインタがあれば、ループは一度だけ書かれ、判定がパラメータになります。

本当の見返り：qsort

標準ライブラリの qsort は、実際に使うことになる関数ポインタの例です。あらゆる型の配列をソートしますが、それができるのは、要素についてサイズと、あなたが提供する比較関数以外は何も知らないからです。

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

比較関数は2つの const void * - 2つの要素のアドレス - を受け取り、1つ目が先に来るなら負の数、同順なら0、後に来るなら正の数を返します。

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

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;      // 本来の型にキャストし戻してから読む
    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);    // 引数を入れ替えて順序を逆にする
}

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("昇順:  ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);

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

    return 0;
}

その比較関数から持ち帰るべき習慣が2つあります。return x - y; とは決して書かないこと - 賢く見えますが、大きな値や負の値でオーバーフローし、符号を誤って配列の並びを狂わせます。そしてデリファレンスの前にキャストすることであって、後ではありません：*(const int *)a と書きます。void * に対する *a には読むべきものがないからです。

同じ仕組みで、構造体を好きなフィールドでソートできます。

#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);   // 高い順
}

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("スコア順:\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("名前順:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    return 0;
}

(q->score > p->score) - (q->score < p->score) という定石は、引き算もオーバーフローもなしに、ちょうど -1、0、1 のいずれかを返します。そして strcmp はすでに正しい戻り値の約束を持っているので、文字列の比較関数は1行で済みます。

関数ポインタのテーブル

関数ポインタの配列は、if/else の連鎖を表引きに変えます。インタプリタがオペコードを振り分ける方法であり、メニューシステムがコマンドを実行する方法でもあります。

#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, "加算"},
        {'-', op_sub, "減算"},
        {'*', op_mul, "乗算"},
        {'/', op_div, "除算"}
    };
    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);
    }

    // switch を使わずに文字でディスパッチする
    char wanted = '*';
    for (int i = 0; i < n; i++) {
        if (table[i].symbol == wanted) {
            printf("\n'%c' をディスパッチ -> %.2f\n", wanted, table[i].fn(x, y));
            break;
        }
    }

    return 0;
}

演算を追加することが、switch を編集することではなく1行を足すことになりました。これを構造体と組み合わせれば、C言語における標準的なプラグインの形になります - 関数ポインタの構造体こそ、この言語における「インターフェース」の意味です。

噛みついてくるもの

シグネチャは完全に一致しなければなりません。 関数ポインタの型には、パラメータの型と戻り値の型が含まれます。一致しない関数を代入するのは制約違反であり、型の合わないポインタ越しに呼び出すのは、たとえ「動いて」いても未定義動作です。警告を黙らせるために比較関数のシグネチャをキャストしてはいけません - 比較関数のほうを直しましょう。

ヌルの関数ポインタも、やはりヌルポインタです。 データのポインタとまったく同じように、NULL で初期化し、呼ぶ前にチェックしましょう。

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

そのチェックが元を取る理由は ヌルポインタ を見てください。

void ポインタは型安全性を失わせ、型システムはあなた自身になります。 qsort の比較関数の中では、間違った型へキャストすることを何も止めてくれません。double の配列を compare_ints でソートしても、きれいにコンパイルが通り、意味不明な結果を出します。

宣言子の構文はネストします。 関数ポインタを返す関数は int (*get_op(char c))(int, int); です。こう書き始めていることに気づいたら、typedef に手を伸ばしましょう。

typedef int (*BinaryOp)(int, int);
BinaryOp get_op(char c);           // 同じものを、読めるかたちで