5.4. Указатели на функции

Теория

Зачем нужен этот пункт

До этого указатели использовались для хранения адресов объектов: переменных, массивов, строк, динамической памяти. Но в языке C указатель может хранить не только адрес объекта, но и адрес функции.

Указатель на функцию позволяет выбрать, какую функцию вызвать, прямо во время выполнения программы. Это удобно для меню действий, математических вычислений, сортировки, поиска и других задач, где алгоритм должен использовать функцию, переданную извне.

В этом пункте рассматриваются:

Функция тоже имеет адрес

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

int square(int x)
{
    return x * x;
}

Имя square можно использовать не только для обычного вызова:

square(5);

но и как значение, связанное с адресом этой функции.

Указатель на функцию — это переменная, которая хранит адрес функции определённого типа.

Простейший пример указателя на функцию

#include <stdio.h>

int square(int x);

int main(void)
{
    int (*operation)(int);

    operation = square;

    printf("%d\n", operation(5));

    return 0;
}

int square(int x)
{
    return x * x;
}

Здесь:

Объявление указателя на функцию

Общая форма объявления указателя на функцию:

тип_результата (*имя_указателя)(типы_параметров);

Например:

int (*p)(int);

Эта запись означает: p — указатель на функцию, которая принимает один параметр типа int и возвращает значение типа int.

Другие примеры:

double (*pf)(double);
int (*cmp)(const void *, const void *);
void (*action)(void);
char (*converter)(char);

Синтаксис выглядит непривычно, потому что символ * и имя указателя должны быть заключены в круглые скобки.

Почему нужны скобки

Рассмотрим две похожие записи:

int *f(void);
int (*p)(void);

Они означают совершенно разные вещи.

Запись Смысл
int *f(void); f — функция, которая возвращает указатель на int
int (*p)(void); p — указатель на функцию, которая возвращает int

Скобки в (*p) нужны, чтобы показать: указателем является именно p, а не результат функции.

Тип указателя должен соответствовать типу функции

Указатель на функцию имеет строгий тип. Он должен соответствовать:

int f1(int x);
double f2(double x);
int f3(int a, int b);

int (*p)(int);

p = f1;  /* правильно */
p = f2;  /* ошибка типа */
p = f3;  /* ошибка типа */

Указатель p подходит только для функций вида:

int имя(int);

Адрес функции

В выражении имя функции обычно преобразуется в указатель на эту функцию.

operation = square;

Можно также явно написать операцию взятия адреса:

operation = &square;

В большинстве обычных случаев обе записи работают одинаково. В учебном коде чаще пишут просто имя функции:

operation = square;

Это читается как: записать в указатель operation адрес функции square.

Вызов функции через указатель

Функцию через указатель можно вызвать двумя способами.

(*p)(аргументы);
p(аргументы);

Например:

int result;

result = (*operation)(5);
result = operation(5);

Обе записи вызывают функцию, адрес которой хранится в указателе operation.

Первый вариант явно показывает разыменование указателя. Второй вариант короче и часто используется в современном C-коде.

Почему запись *p() ошибочна

Нельзя писать вызов так:

*p();  /* ошибка по смыслу */

Операция вызова функции () имеет более высокий приоритет, чем разыменование *. Поэтому такая запись понимается как:

*(p())

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

Правильно:

(*p)();

или проще:

p();

Пример: выбор математической операции

#include <stdio.h>

int add(int a, int b);
int subtract(int a, int b);
int multiply(int a, int b);

int main(void)
{
    int (*operation)(int, int);
    int x = 10;
    int y = 5;

    operation = add;
    printf("add = %d\n", operation(x, y));

    operation = subtract;
    printf("subtract = %d\n", operation(x, y));

    operation = multiply;
    printf("multiply = %d\n", operation(x, y));

    return 0;
}

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

Один и тот же указатель operation по очереди хранит адреса разных функций. Все эти функции имеют одинаковый тип:

int имя(int, int)

Проверка указателя на NULL

Указатель на функцию, как и обычный указатель, может быть равен NULL. Если указатель не содержит адрес функции, вызывать его нельзя.

int (*operation)(int, int) = NULL;

if (operation != NULL)
{
    printf("%d\n", operation(10, 5));
}

Вызов через NULL-указатель приведёт к ошибке.

operation(10, 5);  /* опасно, если operation == NULL */

Указатель на функцию как параметр функции

Указатель на функцию можно передать в другую функцию как параметр. Это позволяет сделать функцию более универсальной.

int apply(int x, int (*operation)(int));

Здесь параметр operation — указатель на функцию, которая принимает int и возвращает int.

#include <stdio.h>

int square(int x);
int cube(int x);
int apply(int x, int (*operation)(int));

int main(void)
{
    printf("%d\n", apply(5, square));
    printf("%d\n", apply(5, cube));

    return 0;
}

int square(int x)
{
    return x * x;
}

int cube(int x)
{
    return x * x * x;
}

int apply(int x, int (*operation)(int))
{
    return operation(x);
}

Функция apply не знает заранее, какую операцию нужно выполнить. Она получает нужную функцию через параметр operation.

Функция обратного вызова

Функцию, адрес которой передаётся другой функции для последующего вызова, часто называют функцией обратного вызова, или callback-функцией.

int apply(int x, int (*callback)(int));

В этом примере callback — это функция, которую apply вызовет внутри себя.

Такой приём используется, когда общая функция знает схему работы, но конкретное действие должно задаваться отдельно.

Пример: обработка массива выбранной функцией

#include <stdio.h>

int square(int x);
int doubleValue(int x);
void transformArray(int a[], int n, int (*operation)(int));

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

    transformArray(numbers, 5, square);

    for (i = 0; i < 5; i++)
    {
        printf("%d ", numbers[i]);
    }

    printf("\n");

    transformArray(numbers, 5, doubleValue);

    for (i = 0; i < 5; i++)
    {
        printf("%d ", numbers[i]);
    }

    printf("\n");

    return 0;
}

int square(int x)
{
    return x * x;
}

int doubleValue(int x)
{
    return x * 2;
}

void transformArray(int a[], int n, int (*operation)(int))
{
    int i;

    if (a == NULL || operation == NULL)
    {
        return;
    }

    for (i = 0; i < n; i++)
    {
        a[i] = operation(a[i]);
    }
}

Функция transformArray умеет пройти по массиву. А то, что именно делать с каждым элементом, задаётся через указатель на функцию operation.

Указатель на функцию и математические вычисления

Указатели на функции особенно удобны в задачах, где один и тот же алгоритм должен работать с разными математическими функциями.

Например, можно написать функцию, которая вычисляет таблицу значений любой функции вида:

double f(double x)

Тогда сама функция табулирования может принимать указатель:

void printTable(double (*f)(double), double from, double to, double step);

Пример: таблица значений функции

#include <stdio.h>
#include <math.h>

void printTable(double (*f)(double), double from, double to, double step);

int main(void)
{
    printf("sin(x):\n");
    printTable(sin, 0.0, 1.0, 0.25);

    printf("\ncos(x):\n");
    printTable(cos, 0.0, 1.0, 0.25);

    return 0;
}

void printTable(double (*f)(double), double from, double to, double step)
{
    double x;

    if (f == NULL || step <= 0.0)
    {
        return;
    }

    for (x = from; x <= to; x += step)
    {
        printf("%8.3f %12.6f\n", x, f(x));
    }
}

Функция printTable не привязана к конкретной функции sin или cos. Она получает нужную функцию через параметр f.

При сборке с GCC для математических функций может понадобиться подключение математической библиотеки:

gcc main.c -lm -o program

Пример: приближённый интеграл

Один и тот же алгоритм численного интегрирования можно применять к разным функциям, если передавать подынтегральную функцию через указатель.

#include <stdio.h>
#include <math.h>

double rectangle(double (*f)(double), double a, double b);
double ratio(double x);
double cosFunction(double x);

int main(void)
{
    printf("integral 1 = %f\n", rectangle(ratio, -1.0, 2.0));
    printf("integral 2 = %f\n", rectangle(cosFunction, 0.0, 0.5));

    return 0;
}

double rectangle(double (*f)(double), double a, double b)
{
    int n = 20;
    int i;
    double h;
    double sum = 0.0;
    double x;

    if (f == NULL)
    {
        return 0.0;
    }

    h = (b - a) / n;

    for (i = 0; i < n; i++)
    {
        x = a + h / 2.0 + i * h;
        sum += f(x);
    }

    return h * sum;
}

double ratio(double x)
{
    double z;

    z = x * x + 1.0;

    return x / (z * z);
}

double cosFunction(double x)
{
    double c;

    c = cos(x);

    return 4.0 * c * c;
}

Функция rectangle знает алгоритм вычисления интеграла методом прямоугольников. Но она не знает заранее, какую именно математическую функцию нужно интегрировать. Это задаётся параметром double (*f)(double).

Массив указателей на функции

Можно создать массив, элементы которого являются указателями на функции.

int (*operations[3])(int, int);

Эта запись означает: operations — массив из трёх указателей на функции, каждая из которых принимает два int и возвращает int.

Такой массив удобно использовать для выбора действия по номеру.

operations[0] = add;
operations[1] = subtract;
operations[2] = multiply;

Пример: массив операций

#include <stdio.h>

int add(int a, int b);
int subtract(int a, int b);
int multiply(int a, int b);

int main(void)
{
    int (*operations[3])(int, int) = {
        add,
        subtract,
        multiply
    };

    int x = 10;
    int y = 5;
    int choice;

    printf("1 - add\n");
    printf("2 - subtract\n");
    printf("3 - multiply\n");
    printf("Выберите операцию: ");
    scanf("%d", &choice);

    if (choice >= 1 && choice <= 3)
    {
        printf("result = %d\n", operations[choice - 1](x, y));
    }
    else
    {
        printf("Неверный выбор\n");
    }

    return 0;
}

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

Здесь номер пункта меню используется как индекс массива. Выбранный элемент массива содержит адрес нужной функции.

Массив функций создать нельзя

В C нельзя создать массив самих функций.

int functions[3](int, int);  /* так нельзя */

Но можно создать массив указателей на функции:

int (*functions[3])(int, int);

Это логично: функция — это код, а не обычный объект данных. Но адреса функций можно хранить в массиве.

typedef для указателя на функцию

Объявления указателей на функции часто выглядят сложно. Чтобы сделать код понятнее, используют typedef.

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

Эта запись вводит имя типа Operation. Теперь Operation означает:

указатель на функцию, принимающую два int и возвращающую int

После этого можно писать проще:

Operation op;
Operation operations[3];

Вместо:

int (*op)(int, int);
int (*operations[3])(int, int);

Пример с typedef

#include <stdio.h>

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

int add(int a, int b);
int subtract(int a, int b);
int multiply(int a, int b);

int main(void)
{
    Operation operations[] = {
        add,
        subtract,
        multiply
    };

    int choice;
    int x = 10;
    int y = 5;

    printf("1 - add\n");
    printf("2 - subtract\n");
    printf("3 - multiply\n");
    printf("Выберите операцию: ");
    scanf("%d", &choice);

    if (choice >= 1 && choice <= 3)
    {
        Operation selected = operations[choice - 1];

        printf("result = %d\n", selected(x, y));
    }
    else
    {
        printf("Неверный выбор\n");
    }

    return 0;
}

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

Благодаря typedef код становится заметно проще: вместо длинной записи указателя на функцию используется имя Operation.

Функция, возвращающая указатель на функцию

Функция может вернуть указатель на другую функцию. Такая запись выглядит сложно, но часто используется для меню и выбора действия.

Без typedef прототип может выглядеть так:

int (*selectOperation(int choice))(int, int);

Читать это нужно так: selectOperation — функция, которая принимает int и возвращает указатель на функцию, принимающую два int и возвращающую int.

С typedef намного понятнее:

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

Operation selectOperation(int choice);

Пример: функция выбирает операцию

#include <stdio.h>

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

int add(int a, int b);
int subtract(int a, int b);
int multiply(int a, int b);
Operation selectOperation(int choice);

int main(void)
{
    int choice;
    int x = 10;
    int y = 5;
    Operation operation;

    printf("1 - add\n");
    printf("2 - subtract\n");
    printf("3 - multiply\n");
    printf("Выберите операцию: ");
    scanf("%d", &choice);

    operation = selectOperation(choice);

    if (operation == NULL)
    {
        printf("Неверный выбор\n");
        return 0;
    }

    printf("result = %d\n", operation(x, y));

    return 0;
}

Operation selectOperation(int choice)
{
    if (choice == 1)
    {
        return add;
    }

    if (choice == 2)
    {
        return subtract;
    }

    if (choice == 3)
    {
        return multiply;
    }

    return NULL;
}

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

Функция selectOperation возвращает адрес выбранной функции. Если выбор неверный, возвращается NULL.

Меню действий через указатели на функции

Указатели на функции позволяют строить меню без длинной цепочки if или switch, если все действия имеют одинаковый тип.

#include <stdio.h>

typedef void (*MenuAction)(void);

void showInfo(void);
void runTask(void);
void showHelp(void);

int main(void)
{
    MenuAction actions[] = {
        showInfo,
        runTask,
        showHelp
    };

    int choice;

    printf("1 - Информация\n");
    printf("2 - Выполнить задачу\n");
    printf("3 - Справка\n");
    printf("Выберите пункт: ");
    scanf("%d", &choice);

    if (choice >= 1 && choice <= 3)
    {
        actions[choice - 1]();
    }
    else
    {
        printf("Неверный пункт меню\n");
    }

    return 0;
}

void showInfo(void)
{
    printf("Информация о программе\n");
}

void runTask(void)
{
    printf("Задача выполнена\n");
}

void showHelp(void)
{
    printf("Справка по программе\n");
}

Все функции меню имеют тип:

void имя(void)

Поэтому их адреса можно хранить в одном массиве MenuAction actions[].

Указатель на функцию в структуре

Указатель на функцию может быть полем структуры. Это удобно, если нужно связать название действия и саму функцию.

#include <stdio.h>

typedef void (*Action)(void);

struct MenuItem
{
    const char *title;
    Action action;
};

void start(void);
void settings(void);
void exitProgram(void);

int main(void)
{
    struct MenuItem menu[] = {
        { "Start", start },
        { "Settings", settings },
        { "Exit", exitProgram }
    };

    int i;

    for (i = 0; i < 3; i++)
    {
        printf("%d. %s\n", i + 1, menu[i].title);
    }

    menu[0].action();

    return 0;
}

void start(void)
{
    printf("Start selected\n");
}

void settings(void)
{
    printf("Settings selected\n");
}

void exitProgram(void)
{
    printf("Exit selected\n");
}

Здесь каждый пункт меню содержит текстовое название и адрес функции, которую нужно вызвать.

qsort и функция сравнения

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

#include <stdlib.h>

Упрощённо прототип выглядит так:

void qsort(
    void *base,
    size_t count,
    size_t size,
    int (*compare)(const void *, const void *)
);

Последний параметр compare — указатель на функцию сравнения. Именно эта функция задаёт правило сортировки.

Пример: сортировка массива int через qsort

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

int compareInt(const void *p1, const void *p2);

int main(void)
{
    int a[6] = { 5, 2, 9, 1, 7, 3 };
    int i;

    qsort(a, 6, sizeof(a[0]), compareInt);

    for (i = 0; i < 6; i++)
    {
        printf("%d ", a[i]);
    }

    printf("\n");

    return 0;
}

int compareInt(const void *p1, const void *p2)
{
    const int *a = p1;
    const int *b = p2;

    if (*a < *b)
    {
        return -1;
    }

    if (*a > *b)
    {
        return 1;
    }

    return 0;
}

Функция compareInt получает два указателя типа const void *. Внутри она приводит их к указателям на int и сравнивает значения.

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

Почему qsort использует void *

Функция qsort должна уметь сортировать массивы разных типов: int, double, структуры и другие данные. Поэтому она работает с адресами через обобщённый тип void *.

Но функция сравнения должна знать настоящий тип элементов. Поэтому внутри функции сравнения указатели приводятся к нужному типу.

const int *a = p1;
const int *b = p2;

После этого можно разыменовать указатели и сравнить значения:

*a < *b

Указатели на функции и void *

Обычные указатели на данные и указатели на функции — это разные виды указателей.

int *dataPointer;
int (*functionPointer)(int);

Не стоит без необходимости преобразовывать указатель на функцию к void * или обратно. Для обычной переносимой программы указатели на функции нужно хранить в указателях подходящего функционального типа.

Правильно:

int square(int x);

int (*p)(int) = square;

Плохо по стилю и переносимости:

void *p = square;

Указатели на функции и switch

Иногда выбор функции можно сделать обычным switch.

switch (choice)
{
    case 1:
        result = add(x, y);
        break;

    case 2:
        result = subtract(x, y);
        break;
}

Это нормально для небольшого количества вариантов. Указатели на функции становятся особенно удобными, когда:

Как читать сложные объявления

Сложные объявления с указателями на функции лучше разбирать от имени.

int (*p)(double);

Читаем:

Значит:

p — указатель на функцию, которая принимает double и возвращает int

Для сложных случаев лучше использовать typedef.

Типичные ошибки

Ошибка 1. Забыли скобки в объявлении

int *p(int);

Это не указатель на функцию. Это прототип функции, которая возвращает int *. Для указателя нужно:

int (*p)(int);

Ошибка 2. Неверный тип функции

int (*p)(int);

double f(double x);

p = f;  /* ошибка типа */

Указатель и функция должны иметь совместимые типы.

Ошибка 3. Вызов через NULL

int (*p)(int) = NULL;

printf("%d\n", p(5));  /* ошибка */

Перед вызовом нужно проверить указатель:

if (p != NULL)
{
    printf("%d\n", p(5));
}

Ошибка 4. Запись *p() вместо (*p)()

*p();  /* ошибка по смыслу */

Нужно:

(*p)();

или:

p();

Ошибка 5. Попытка создать массив функций

int functions[3](int);  /* нельзя */

Можно создать массив указателей на функции:

int (*functions[3])(int);

Ошибка 6. Слишком сложные объявления без typedef

int (*(*select(int mode))(int, int))(int);

Такой код трудно читать. Если объявление становится сложным, лучше ввести понятное имя типа через typedef.

Ошибка 7. Передача функции с неподходящим прототипом

void transformArray(int a[], int n, int (*operation)(int));

double sqrt(double);

transformArray(a, n, sqrt);  /* ошибка типа */

sqrt принимает double и возвращает double, а функция ожидает указатель на функцию вида int имя(int).

Ошибка 8. Считать указатель на функцию обычным указателем на данные

void *p = add;  /* плохая идея */

Для адресов функций нужно использовать указатели на функции соответствующего типа.

Практические рекомендации

Мини-разбор программы

Программа выбирает математическую операцию через массив указателей на функции.

#include <stdio.h>

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

int add(int a, int b);
int subtract(int a, int b);
int multiply(int a, int b);
int divideSafe(int a, int b);

int main(void)
{
    Operation operations[] = {
        add,
        subtract,
        multiply,
        divideSafe
    };

    const char *names[] = {
        "Сложение",
        "Вычитание",
        "Умножение",
        "Деление"
    };

    int choice;
    int x;
    int y;
    int count;
    int i;

    count = sizeof(operations) / sizeof(operations[0]);

    printf("Введите два числа: ");
    scanf("%d%d", &x, &y);

    for (i = 0; i < count; i++)
    {
        printf("%d - %s\n", i + 1, names[i]);
    }

    printf("Выберите операцию: ");
    scanf("%d", &choice);

    if (choice < 1 || choice > count)
    {
        printf("Неверный выбор\n");
        return 0;
    }

    printf("result = %d\n", operations[choice - 1](x, y));

    return 0;
}

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 divideSafe(int a, int b)
{
    if (b == 0)
    {
        return 0;
    }

    return a / b;
}

Разберём программу:

Что нужно запомнить

Самопроверка перед переходом дальше

  1. Что такое указатель на функцию?
  2. Как объявить указатель на функцию, принимающую int и возвращающую int?
  3. Почему в объявлении int (*p)(int) нужны скобки?
  4. Чем отличается int *f(void) от int (*f)(void)?
  5. Как записать адрес функции square в указатель?
  6. Какими двумя способами можно вызвать функцию через указатель?
  7. Почему запись *p() неправильна для вызова функции через указатель?
  8. Почему тип указателя на функцию должен совпадать с типом функции?
  9. Как передать функцию в другую функцию как параметр?
  10. Что такое callback-функция?
  11. Как объявить массив указателей на функции?
  12. Почему нельзя создать массив самих функций?
  13. Для чего удобно использовать typedef?
  14. Как функция может вернуть указатель на функцию?
  15. Для чего qsort нужен указатель на функцию сравнения?
  16. Почему указатель на функцию не стоит хранить в void *?