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

Введение

Указатели могут указывать не только на данные, но и на функции — в этой статье разберём указатели на функции, их синтаксис (один из наиболее визуально сложных в C/C++) и практическое применение, частично пересекающееся с лямбда-выражениями современного C++ , но представляющее более фундаментальный, низкоуровневый механизм.

Концепция

Указатель на функцию хранит адрес начала кода конкретной функции, и через такой указатель можно вызвать эту функцию косвенно — это позволяет передавать функции как параметры других функций (классический паттерн «функция высшего порядка», также реализуемый в современном C++ через std::function или шаблоны со стандартными функциональными объектами) или хранить ссылку на одну из нескольких альтернативных функций для вызова, выбираемого динамически во время выполнения. Синтаксис объявления указателя на функцию (тип_возврата (*имя_указателя)(типы_параметров)) исторически считается одним из наименее интуитивных аспектов синтаксиса C/C++ именно из-за необходимости явных скобок вокруг имени указателя для правильного разбора компилятором приоритета операций.

Пример кода

#include <iostream>

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

int main()
{
    int (*operation)(int, int); // указатель на функцию, принимающую (int, int) и возвращающую int

    operation = add; // указатель присваивается АДРЕСУ функции — без вызова, без круглых скобок ()
    std::cout << operation(3, 4) << std::endl; // 7 — вызов ЧЕРЕЗ указатель, синтаксически как обычный вызов

    operation = multiply; // переключение на другую функцию во время выполнения
    std::cout << operation(3, 4) << std::endl; // 12

    return 0;
}

// Указатель на функцию как параметр — классический паттерн "функция высшего порядка"
#include <iostream>

void processArray(int *array, int size, void (*processor)(int))
{
    for (int i = 0; i < size; ++i) {
        processor(array[i]); // вызов переданной функции для каждого элемента
    }
}

void printValue(int value) { std::cout << value << " "; }
void printSquared(int value) { std::cout << value * value << " "; }

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

    processArray(numbers, 5, printValue);   // 1 2 3 4 5
    std::cout << std::endl;
    processArray(numbers, 5, printSquared); // 1 4 9 16 25

    return 0;
}

// typedef/using для упрощения сложного синтаксиса указателей на функции
#include <iostream>

using BinaryOperation = int (*)(int, int); // современный, более читаемый синтаксис через using 

int subtract(int a, int b) { return a - b; }

void demonstrateUsing()
{
    BinaryOperation op = subtract; // значительно понятнее, чем "int (*op)(int, int) = subtract;"
    std::cout << op(10, 3) << std::endl; // 7
}

Пояснения к коду

int (*operation)(int, int); показывает классический, не самый интуитивный синтаксис объявления указателя на функцию — скобки вокруг *operation обязательны, поскольку без них (int *operation(int, int);) выражение было бы разобрано как объявление функции, возвращающей int*, а не как переменную-указатель на функцию, возвращающую int — это тонкое, но критичное синтаксическое различие. processArray с параметром void (*processor)(int) показывает классическое применение указателей на функции до появления лямбд и std::function — функция принимает в качестве параметра указатель на другую функцию, вызываемую для обработки каждого элемента массива, что даёт гибкость в определении конкретного поведения обработки без изменения самой processArray. using BinaryOperation = int (*)(int, int); показывает современный, значительно более читаемый способ объявления типа указателя на функцию через псевдоним, избегающий необходимости каждый раз заново разбираться со сложным, многоступенчатым синтаксисом прямого объявления.

Подводные камни

Путаница в синтаксисе объявления указателя на функцию без скобок вокруг имени, как показано в пояснении к примеру — пропущенные скобки полностью меняют смысл объявления (превращая его в объявление функции, а не указателя на функцию), и эта тонкая синтаксическая деталь — частый источник ошибок компиляции для разработчиков, не до конца уверенных в точном синтаксисе этой конструкции, что является одной из причин, почему современный C++ код предпочитает using-псевдонимы (как в третьем примере) или, ещё чаще, std::function/лямбды вместо прямого синтаксиса указателей на функции.
Использование «сырых» указателей на функции в новом коде вместо std::function или лямбд там, где нужна более широкая гибкость — указатель на функцию может ссылаться только на обычную, свободную функцию (или статический метод класса) с точно соответствующей сигнатурой, но не может непосредственно «захватить» дополнительный контекст (как захват переменных в лямбда-выражениях, и для случаев, требующих такой гибкости, std::function в сочетании с лямбдами — более современная и удобная альтернатива, хотя указатели на функции остаются актуальными для взаимодействия с C-API, многие из которых ожидают именно простой указатель на функцию, а не более сложные конструкции C++.
Передача указателя на функцию с несоответствующей сигнатурой, что компилятор обычно обнаруживает как ошибку типов на этапе компиляции (в отличие от многих других, менее строго типизированных языков), но определённые случаи (особенно при использовании void* или явных, принудительных приведений типов указателей на функции) могут обойти эту проверку компилятора, что для несовместимых по реальной сигнатуре функций является неопределённым поведением при попытке вызова через такой неправильно типизированный указатель.
Сравнение указателей на функции для определения «одинаковости» поведения двух функций — указатель на функцию сравнивается как обычный адрес, что корректно определяет, ссылаются ли два указателя на ОДНУ И ТУ ЖЕ функцию, но не может определить функциональную эквивалентность двух РАЗНЫХ функций, даже если они дают идентичный результат для всех возможных входных данных — это ограничение присуще самой природе указателей как адресов, а не более глубокому, семантическому пониманию поведения функции.