Указатели на функции в 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("сложение:   %d\n", op(10, 3));

    op = subtract;              // направляем в другое место
    printf("вычитание:  %d\n", op(10, 3));

    op = &multiply;             // & допустим, но избыточен
    printf("умножение:  %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.

Колбэки: пусть поведение задаёт вызывающий

Колбэк — это функция, которую вы передаёте другой функции, чтобы та могла вызвать вас в нужный момент. Это позволяет одному куску кода управлять структурой работы, пока вызывающий поставляет решение.

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

// одна функция, любая проверка
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 — три копии одного и того же цикла. С ними цикл пишется один раз, а параметром становится проверка.

Настоящая отдача: qsort

qsort из стандартной библиотеки — тот пример указателей на функции, которым вы действительно будете пользоваться. Он сортирует массив чего угодно, и удаётся ему это потому, что об элементах он не знает ничего, кроме их размера и предоставленного вами компаратора.

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

Компаратор получает два const void * — адреса двух элементов — и возвращает отрицательное число, если первый должен идти раньше второго, ноль при равенстве и положительное, если он идёт позже.

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

Из этого компаратора стоит вынести две привычки. Никогда не пишите return x - y; — выглядит хитро, но переполняется на больших или отрицательных значениях, давая неверный знак и неправильно отсортированный массив. Приводите тип до разыменования, а не после: *(const int *)a, потому что у *a для void * нечего читать.

Та же машинерия сортирует структуры по любому полю:

#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 уже правильное соглашение о возвращаемом значении, поэтому строковый компаратор умещается в одну строку.

Таблицы указателей на функции

Массив указателей на функции превращает цепочку 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. Соедините это со структурами — и получите стандартную для 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);           // то же самое, но читаемо