Как работают указатели на функции в C?

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

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

13 ответов

Решение

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

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

int addInt(int n, int m) {
    return n+m;
}

Прежде всего, давайте определим указатель на функцию, которая получает 2 intс и возвращает int:

int (*functionPtr)(int,int);

Теперь мы можем смело указать на нашу функцию:

functionPtr = &addInt;

Теперь, когда у нас есть указатель на функцию, давайте ее использовать:

int sum = (*functionPtr)(2, 3); // sum == 5

Передача указателя на другую функцию в основном такая же:

int add2to3(int (*functionPtr)(int, int)) {
    return (*functionPtr)(2, 3);
}

Мы также можем использовать указатели на функции в возвращаемых значениях (старайтесь не отставать, это становится грязным):

// this is a function called functionFactory which receives parameter n
// and returns a pointer to another function which receives two ints
// and it returns another int
int (*functionFactory(int n))(int, int) {
    printf("Got parameter %d", n);
    int (*functionPtr)(int,int) = &addInt;
    return functionPtr;
}

Но гораздо приятнее использовать typedef:

typedef int (*myFuncDef)(int, int);
// note that the typedef name is indeed myFuncDef

myFuncDef functionFactory(int n) {
    printf("Got parameter %d", n);
    myFuncDef functionPtr = &addInt;
    return functionPtr;
}

Функциональные указатели в C могут использоваться для выполнения объектно-ориентированного программирования в C.

Например, следующие строки написаны на C:

String s1 = newString();
s1->set(s1, "hello");

Да, -> и отсутствие new оператор мертвый отдавать, но это, кажется, подразумевает, что мы устанавливаем текст некоторых String класс быть "hello",

Используя указатели функций, можно эмулировать методы в Си.

Как это достигается?

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

typedef struct String_Struct* String;

struct String_Struct
{
    char* (*get)(const void* self);
    void (*set)(const void* self, char* value);
    int (*length)(const void* self);
};

char* getString(const void* self);
void setString(const void* self, char* value);
int lengthString(const void* self);

String newString();

Как видно, методы String класс на самом деле являются указателями на функции для объявленной функции. При подготовке экземпляра String, newString Функция вызывается для того, чтобы установить указатели функций на их соответствующие функции:

String newString()
{
    String self = (String)malloc(sizeof(struct String_Struct));

    self->get = &getString;
    self->set = &setString;
    self->length = &lengthString;

    self->set(self, "");

    return self;
}

Например, getString функция, которая вызывается путем вызова get Метод определяется следующим образом:

char* getString(const void* self_obj)
{
    return ((String)self_obj)->internal->value;
}

Одна вещь, которую можно заметить, заключается в том, что не существует концепции экземпляра объекта и наличия методов, которые на самом деле являются частью объекта, поэтому "собственный объект" должен передаваться при каждом вызове. (И internal это просто скрытый struct который был опущен в листинге кода ранее - это способ скрытия информации, но это не относится к указателям на функции.)

Так что вместо того, чтобы делать s1->set("hello");нужно пройти в объект, чтобы выполнить действие на s1->set(s1, "hello"),

С этим небольшим объяснением, которое необходимо передать со ссылкой на себя, мы перейдем к следующей части, которая является наследованием в C.

Допустим, мы хотим сделать подкласс Stringскажи ImmutableString, Чтобы сделать строку неизменной, set метод не будет доступен при сохранении доступа к get а также lengthи заставить "конструктор" принять char*:

typedef struct ImmutableString_Struct* ImmutableString;

struct ImmutableString_Struct
{
    String base;

    char* (*get)(const void* self);
    int (*length)(const void* self);
};

ImmutableString newImmutableString(const char* value);

По сути, для всех подклассов доступные методы снова являются указателями на функции. На этот раз декларация для set метод отсутствует, поэтому он не может быть вызван в ImmutableString,

Что касается реализации ImmutableString, единственный соответствующий код является функцией "конструктор", newImmutableString:

ImmutableString newImmutableString(const char* value)
{
    ImmutableString self = (ImmutableString)malloc(sizeof(struct ImmutableString_Struct));

    self->base = newString();

    self->get = self->base->get;
    self->length = self->base->length;

    self->base->set(self->base, (char*)value);

    return self;
}

В создании ImmutableStringфункция указывает на get а также length методы на самом деле относятся к String.get а также String.length метод, пройдя через base переменная, которая хранится внутри String объект.

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

В дальнейшем мы можем продолжить полиморфизм в C.

Если, например, мы хотим изменить поведение length способ вернуть 0 все время в ImmutableString по какой-то причине, все, что нужно сделать, это:

  1. Добавьте функцию, которая будет служить переопределением length метод.
  2. Перейти к "конструктору" и установить указатель функции на переопределение length метод.

Добавление переопределения length метод в ImmutableString может быть выполнено путем добавления lengthOverrideMethod:

int lengthOverrideMethod(const void* self)
{
    return 0;
}

Затем указатель функции для length Метод в конструкторе подключен к lengthOverrideMethod:

ImmutableString newImmutableString(const char* value)
{
    ImmutableString self = (ImmutableString)malloc(sizeof(struct ImmutableString_Struct));

    self->base = newString();

    self->get = self->base->get;
    self->length = &lengthOverrideMethod;

    self->base->set(self->base, (char*)value);

    return self;
}

Теперь, вместо того, чтобы иметь идентичное поведение для length метод в ImmutableString класс как String класс, теперь length метод будет ссылаться на поведение, определенное в lengthOverrideMethod функция.

Я должен добавить заявление об отказе от ответственности, которое я все еще изучаю, как писать в объектно-ориентированном стиле программирования на C, так что, вероятно, есть моменты, которые я плохо объяснил, или они могут быть просто неуместны с точки зрения того, как лучше всего реализовать ООП. в C. Но моя цель состояла в том, чтобы попытаться проиллюстрировать одно из многих применений указателей функций.

Для получения дополнительной информации о том, как выполнить объектно-ориентированное программирование на C, пожалуйста, обратитесь к следующим вопросам:

Руководство по увольнению: как злоупотреблять указателями функций в GCC на компьютерах с архитектурой x86, компилируя код вручную:

Эти строковые литералы являются байтами 32-битного машинного кода x86. 0xC3 это x86 ret инструкция

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

  1. Возвращает текущее значение в регистре EAX

    int eax = ((int(*)())("\xc3 <- This returns the value of the EAX register"))();
    
  2. Написать функцию подкачки

    int a = 10, b = 20;
    ((void(*)(int*,int*))"\x8b\x44\x24\x04\x8b\x5c\x24\x08\x8b\x00\x8b\x1b\x31\xc3\x31\xd8\x31\xc3\x8b\x4c\x24\x04\x89\x01\x8b\x4c\x24\x08\x89\x19\xc3 <- This swaps the values of a and b")(&a,&b);
    
  3. Запишите счетчик цикла для 1000, каждый раз вызывая некоторую функцию

    ((int(*)())"\x66\x31\xc0\x8b\x5c\x24\x04\x66\x40\x50\xff\xd3\x58\x66\x3d\xe8\x03\x75\xf4\xc3")(&function); // calls function with 1->1000
    
  4. Вы даже можете написать рекурсивную функцию, которая считает до 100

    const char* lol = "\x8b\x5c\x24\x4\x3d\xe8\x3\x0\x0\x7e\x2\x31\xc0\x83\xf8\x64\x7d\x6\x40\x53\xff\xd3\x5b\xc3\xc3 <- Recursively calls the function at address lol.";
    i = ((int(*)())(lol))(lol);
    

Обратите внимание, что компиляторы помещают строковые литералы в .rodata раздел (или .rdata в Windows), который связан как часть текстового сегмента (вместе с кодом для функций).

Текстовый сегмент имеет разрешение Read+Exec, поэтому приведение строковых литералов к указателям на функции работает без необходимости mprotect() или же VirtualProtect() системные вызовы, как вам нужно для динамически распределенной памяти. (Или же gcc -z execstack связывает программу со стеком + сегмент данных + исполняемый файл кучи, как быстрый взлом.)


Чтобы разобрать их, вы можете скомпилировать их, чтобы поместить метку в байты, и использовать дизассемблер.

// at global scope
const char swap[] = "\x8b\x44\x24\x04\x8b\x5c\x24\x08\x8b\x00\x8b\x1b\x31\xc3\x31\xd8\x31\xc3\x8b\x4c\x24\x04\x89\x01\x8b\x4c\x24\x08\x89\x19\xc3 <- This swaps the values of a and b";

Компилирование с gcc -c -m32 foo.c и разбирать с objdump -D -rwC -Mintel мы можем получить сборку и выяснить, что этот код нарушает ABI, забивая EBX (регистр, сохраняющий вызов), и, как правило, неэффективен.

00000000 <swap>:
   0:   8b 44 24 04             mov    eax,DWORD PTR [esp+0x4]   # load int *a arg from the stack
   4:   8b 5c 24 08             mov    ebx,DWORD PTR [esp+0x8]   # ebx = b
   8:   8b 00                   mov    eax,DWORD PTR [eax]       # dereference: eax = *a
   a:   8b 1b                   mov    ebx,DWORD PTR [ebx]
   c:   31 c3                   xor    ebx,eax                # pointless xor-swap
   e:   31 d8                   xor    eax,ebx                # instead of just storing with opposite registers
  10:   31 c3                   xor    ebx,eax
  12:   8b 4c 24 04             mov    ecx,DWORD PTR [esp+0x4]  # reload a from the stack
  16:   89 01                   mov    DWORD PTR [ecx],eax     # store to *a
  18:   8b 4c 24 08             mov    ecx,DWORD PTR [esp+0x8]
  1c:   89 19                   mov    DWORD PTR [ecx],ebx
  1e:   c3                      ret    

  not shown: the later bytes are ASCII text documentation
  they're not executed by the CPU because the ret instruction sends execution back to the caller

Этот машинный код (вероятно) будет работать в 32-битном коде в Windows, Linux, OS X и т. Д.: Соглашения о вызовах по умолчанию во всех этих ОС передают аргументы в стеке, а не более эффективно в регистрах. Но EBX сохраняется во всех обычных соглашениях о вызовах, поэтому использование его в качестве рабочего регистра без сохранения / восстановления может легко вызвать сбой вызывающего абонента.

Одно из моих любимых применений для указателей на функции - это дешевые и простые итераторы -

#include <stdio.h>
#define MAX_COLORS  256

typedef struct {
    char* name;
    int red;
    int green;
    int blue;
} Color;

Color Colors[MAX_COLORS];


void eachColor (void (*fp)(Color *c)) {
    int i;
    for (i=0; i<MAX_COLORS; i++)
        (*fp)(&Colors[i]);
}

void printColor(Color* c) {
    if (c->name)
        printf("%s = %i,%i,%i\n", c->name, c->red, c->green, c->blue);
}

int main() {
    Colors[0].name="red";
    Colors[0].red=255;
    Colors[1].name="blue";
    Colors[1].blue=255;
    Colors[2].name="black";

    eachColor(printColor);
}

Указатели на функции легко объявляются, когда у вас есть основные деклараторы:

  • Я бы: ID: ID является
  • Указатель: *D: D указатель на
  • Функция: D(<parameters>): D функция взятия < параметры > возврате

В то время как D - еще один декларатор, созданный по тем же правилам. В конце концов, где-то это заканчивается ID (см. пример ниже), которое является именем объявленной сущности. Давайте попробуем построить функцию, которая берет указатель на функцию, которая ничего не берет и возвращает int, и возвращает указатель на функцию, которая принимает char и возвращает int. С type-def это так

typedef int ReturnFunction(char);
typedef int ParameterFunction(void);
ReturnFunction *f(ParameterFunction *p);

Как видите, его довольно легко собрать с помощью typedefs. Без typedefs это не сложно и с указанными выше правилами декларатора, применяемыми последовательно. Как видите, я пропустил ту часть, на которую указывает указатель, и функцию, которую возвращает функция. Это то, что появляется в самом левом углу объявления, и не представляет интереса: оно добавляется в конце, если кто-то уже создал декларатор. Давайте сделаем это. Создание его последовательно, первое слово - показ структуры с использованием [ а также ]:

function taking 
    [pointer to [function taking [void] returning [int]]] 
returning
    [pointer to [function taking [char] returning [int]]]

Как видите, можно полностью описать тип, добавив деклараторы один за другим. Строительство может быть сделано двумя способами. Один - снизу вверх, начиная с самой правильной вещи (уходит) и проходя путь до идентификатора. Другой способ - сверху вниз, начиная с идентификатора, работая вниз до листьев. Я покажу оба пути.

Вверх дном

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

D1(char);

Вставил параметр char напрямую, так как он тривиален. Добавление указателя на декларатор путем замены D1 от *D2, Обратите внимание, что мы должны обернуть круглые скобки *D2, Это можно узнать, посмотрев на приоритет *-operator и оператор вызова функции (), Без наших скобок компилятор прочитал бы это как *(D2(char p)), Но это не будет простой заменой D1 на *D2 больше, конечно. Круглые скобки всегда разрешены вокруг деклараторов. Таким образом, вы не делаете ничего плохого, если добавляете слишком много из них, на самом деле.

(*D2)(char);

Тип возврата завершен! Теперь давайте заменим D2 с помощью функции объявления функции <parameters> возвращение, которое D3(<parameters>) что мы находимся сейчас.

(*D3(<parameters>))(char)

Обратите внимание, что скобки не нужны, так как мы хотим D3 на этот раз быть декларатором функции, а не декларатором указателя. Отлично, осталось только параметры для него. Параметр выполняется точно так же, как мы сделали тип возвращаемого значения, только с char заменен на void, Поэтому я скопирую это:

(*D3(   (*ID1)(void)))(char)

Я заменил D2 от ID1, так как мы закончили с этим параметром (это уже указатель на функцию - нет необходимости в другом деклараторе). ID1 будет именем параметра. Теперь, как я сказал выше, в конце добавляется тип, который модифицируют все эти деклараторы - тот, который появляется слева от каждого объявления. Для функций это становится типом возврата. Для указателей, указывающих на тип и т. Д. Интересно, что когда вы записываете тип, он будет отображаться в обратном порядке, в самом праве:) В любом случае, его замена приводит к полному объявлению. Оба раза int конечно.

int (*ID0(int (*ID1)(void)))(char)

Я назвал идентификатор функции ID0 в этом примере.

Низходящий

Это начинается с идентификатора в самом левом углу описания типа, оборачивая этот декларатор, пока мы идем по правому пути. Начните с принятия функций < параметры > возврате

ID0(<parameters>)

Следующей вещью в описании (после "возврата") был указатель на. Давайте включим это:

*ID0(<parameters>)

Затем следующей вещью было принятие functon < параметры > возвращаясь. Параметр представляет собой простой символ, поэтому мы сразу добавляем его, поскольку он действительно тривиален.

(*ID0(<parameters>))(char)

Обратите внимание на скобки, которые мы добавили, так как мы снова хотим, чтобы * связывает сначала, а затем (char), В противном случае это будет читать функцию принятия < параметры > возвращающая функция... Нет, функции, возвращающие функции, даже не разрешены.

Теперь нам просто нужно поставить < параметры >, Я покажу краткую версию вывода, поскольку я думаю, что у вас уже есть идея, как это сделать.

pointer to: *ID1
... function taking void returning: (*ID1)(void)

Просто положи int перед деклараторами, как мы сделали снизу вверх, и мы закончили

int (*ID0(int (*ID1)(void)))(char)

Хорошая вещь

Лучше снизу вверх или сверху вниз? Я привык снизу вверх, но некоторым людям может быть удобнее работать сверху вниз. Это вопрос вкуса, я думаю. Кстати, если вы примените все операторы в этом объявлении, вы получите int:

int v = (*ID0(some_function_pointer))(some_char);

Это хорошее свойство объявлений в C: Объявление утверждает, что если эти операторы используются в выражении, использующем идентификатор, то это приводит к типу слева. Так же и для массивов.

Надеюсь, вам понравился этот маленький урок! Теперь мы можем ссылаться на это, когда люди задаются вопросом о странном синтаксисе объявления функций. Я постарался поставить как можно меньше C-внутренностей. Не стесняйтесь редактировать / исправлять вещи в нем.

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

Их очень удобно использовать, когда вам нужны разные функции в разное время или на разных этапах разработки. Например, я разрабатываю приложение на главном компьютере с консолью, но окончательный выпуск программного обеспечения будет помещен на Avnet ZedBoard (который имеет порты для дисплеев и консолей, но они не нужны / не нужны для Окончательный релиз). Так что во время разработки я буду использовать printf просматривать статус и сообщения об ошибках, но когда я закончу, я не хочу ничего печатать. Вот что я сделал:

version.h

// First, undefine all macros associated with version.h
#undef DEBUG_VERSION
#undef RELEASE_VERSION
#undef INVALID_VERSION


// Define which version we want to use
#define DEBUG_VERSION       // The current version
// #define RELEASE_VERSION  // To be uncommented when finished debugging

#ifndef __VERSION_H_      /* prevent circular inclusions */
    #define __VERSION_H_  /* by using protection macros */
    void board_init();
    void noprintf(const char *c, ...); // mimic the printf prototype
#endif

// Mimics the printf function prototype. This is what I'll actually 
// use to print stuff to the screen
void (* zprintf)(const char*, ...); 

// If debug version, use printf
#ifdef DEBUG_VERSION
    #include <stdio.h>
#endif

// If both debug and release version, error
#ifdef DEBUG_VERSION
#ifdef RELEASE_VERSION
    #define INVALID_VERSION
#endif
#endif

// If neither debug or release version, error
#ifndef DEBUG_VERSION
#ifndef RELEASE_VERSION
    #define INVALID_VERSION
#endif
#endif

#ifdef INVALID_VERSION
    // Won't allow compilation without a valid version define
    #error "Invalid version definition"
#endif

В version.c Я определю 2 прототипа функций, представленных в version.h

version.c

#include "version.h"

/*****************************************************************************/
/**
* @name board_init
*
* Sets up the application based on the version type defined in version.h.
* Includes allowing or prohibiting printing to STDOUT.
*
* MUST BE CALLED FIRST THING IN MAIN
*
* @return    None
*
*****************************************************************************/
void board_init()
{
    // Assign the print function to the correct function pointer
    #ifdef DEBUG_VERSION
        zprintf = &printf;
    #else
        // Defined below this function
        zprintf = &noprintf;
    #endif
}

/*****************************************************************************/
/**
* @name noprintf
*
* simply returns with no actions performed
*
* @return   None
*
*****************************************************************************/
void noprintf(const char* c, ...)
{
    return;
}

Обратите внимание, как указатель на функцию прототипируется в version.h как

void (* zprintf)(const char *, ...);

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

В version.c обратите внимание на board_init() функция где zprintf назначается уникальная функция (чья сигнатура функции совпадает) в зависимости от версии, определенной в version.h

zprintf = &printf; zprintf вызывает printf для отладки

или же

zprintf = &noprint; zprintf просто возвращает и не будет запускать ненужный код

Запуск кода будет выглядеть так:

mainProg.c

#include "version.h"
#include <stdlib.h>
int main()
{
    // Must run board_init(), which assigns the function
    // pointer to an actual function
    board_init();

    void *ptr = malloc(100); // Allocate 100 bytes of memory
    // malloc returns NULL if unable to allocate the memory.

    if (ptr == NULL)
    {
        zprintf("Unable to allocate memory\n");
        return 1;
    }

    // Other things to do...
    return 0;
}

Приведенный выше код будет использовать printf если в режиме отладки, или ничего не делать, если в режиме выпуска. Это намного проще, чем просматривать весь проект, комментировать или удалять код. Все, что мне нужно сделать, это изменить версию в version.h и код сделает все остальное!

Указатель на функцию обычно определяется typedef и используется в качестве параметра и возвращаемого значения,

Выше ответы уже многое объяснили, я просто приведу полный пример:

#include <stdio.h>

#define NUM_A 1
#define NUM_B 2

// define a function pointer type
typedef int (*two_num_operation)(int, int);

// an actual standalone function
static int sum(int a, int b) {
    return a + b;
}

// use function pointer as param,
static int sum_via_pointer(int a, int b, two_num_operation funp) {
    return (*funp)(a, b);
}

// use function pointer as return value,
static two_num_operation get_sum_fun() {
    return &sum;
}

// test - use function pointer as variable,
void test_pointer_as_variable() {
    // create a pointer to function,
    two_num_operation sum_p = &sum;
    // call function via pointer
    printf("pointer as variable:\t %d + %d = %d\n", NUM_A, NUM_B, (*sum_p)(NUM_A, NUM_B));
}

// test - use function pointer as param,
void test_pointer_as_param() {
    printf("pointer as param:\t %d + %d = %d\n", NUM_A, NUM_B, sum_via_pointer(NUM_A, NUM_B, &sum));
}

// test - use function pointer as return value,
void test_pointer_as_return_value() {
    printf("pointer as return value:\t %d + %d = %d\n", NUM_A, NUM_B, (*get_sum_fun())(NUM_A, NUM_B));
}

int main() {
    test_pointer_as_variable();
    test_pointer_as_param();
    test_pointer_as_return_value();

    return 0;
}

Функция запуска с нуля имеет некоторый адрес памяти, с которого они начинают выполняться. На ассемблере они называются как (вызывают "адрес памяти функции"). Теперь возвращаемся к C Если функция имеет адрес памяти, то они могут управляться указателями в C. Так по правилам C

1. Сначала нужно объявить указатель на функцию 2. Передать адрес желаемой функции

**** Примечание-> функции должны быть одного типа ****

Эта простая программа проиллюстрирует каждую вещь.

#include<stdio.h>
void (*print)() ;//Declare a  Function Pointers
void sayhello();//Declare The Function Whose Address is to be passed
                //The Functions should Be of Same Type
int main()
{

 print=sayhello;//Addressof sayhello is assigned to print
 print();//print Does A call To The Function 
 return 0;
}

void sayhello()
{
 printf("\n Hello World");
}

После этого давайте посмотрим, как машина понимает их. Познакомимся с машинными инструкциями вышеупомянутой программы в 32-битной архитектуре.

Область красной метки показывает, как происходит обмен и сохранение адреса в eax. Затем это инструкция вызова на eax. Eax содержит желаемый адрес функции

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

Очень простой пример: если есть одна функция с именем print(int x, int y), которая, в свою очередь, может потребовать вызова функции add() или sub() схожего типа, то, что мы будем делать, мы добавим одну функцию Аргумент указателя на функцию print(), как показано ниже:

int add()
{
   return (100+10);
}

int sub()
{
   return (100-10);
}

void print(int x, int y, int (*func)())
{
    printf("value is : %d", (x+y+(*func)()));
}

int main()
{
    int x=100, y=200;
    print(x,y,add);
    print(x,y,sub);

    return 0;
}

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

Единственное исключение, о котором я могу думать, - это обращение к указателю на функцию, указывающее на что-то, отличное от одного значения. Делать арифметику указателя, увеличивая или уменьшая указатель на функцию или добавляя / вычитая смещение к указателю на функцию, на самом деле не имеет никакого смысла, так как указатель на функцию указывает только на одну вещь, точку входа в функцию.

Размер переменной указателя функции, количество байтов, занимаемых этой переменной, может варьироваться в зависимости от базовой архитектуры, например, x32 или x64 или чего-либо еще.

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

Некоторые примеры:

int func (int a, char *pStr);    // declares a function

int (*pFunc)(int a, char *pStr);  // declares or defines a function pointer

int (*pFunc2) ();                 // declares or defines a function pointer, no parameter list specified.

int (*pFunc3) (void);             // declares or defines a function pointer, no arguments.

Первые два объявления несколько похожи в этом:

  • func это функция, которая принимает int и char * и возвращает int
  • pFunc является указателем на функцию, которой назначен адрес функции, которая принимает int и char * и возвращает int

Таким образом, из вышесказанного мы могли бы иметь исходную строку, в которой адрес функции func() присваивается переменной указателя функции pFunc как в pFunc = func;,

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

int *pfunc(int a, char *pStr);    // declares a function that returns int pointer
int (*pFunc)(int a, char *pStr);  // declares a function pointer that returns an int

Несколько различных примеров использования

Некоторые примеры использования указателя на функцию:

int (*pFunc) (int a, char *pStr);    // declare a simple function pointer variable
int (*pFunc[55])(int a, char *pStr); // declare an array of 55 function pointers
int (**pFunc)(int a, char *pStr);    // declare a pointer to a function pointer variable
struct {                             // declare a struct that contains a function pointer
    int x22;
    int (*pFunc)(int a, char *pStr);
} thing = {0, func};                 // assign values to the struct variable
char * xF (int x, int (*p)(int a, char *pStr));  // declare a function that has a function pointer as an argument
char * (*pxF) (int x, int (*p)(int a, char *pStr));  // declare a function pointer that points to a function that has a function pointer as an argument

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

int sum (int a, int b, ...);
int (*psum)(int a, int b, ...);

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

int  sum ();      // nothing specified in the argument list so could be anything or nothing
int (*psum)();
int  sum2(void);  // void specified in the argument list so no parameters when calling this function
int (*psum2)(void);

C стиль бросает

Вы можете использовать приведения в стиле C с указателями на функции. Однако имейте в виду, что компилятор C может быть слаб в проверках или предоставлять предупреждения, а не ошибки.

int sum (int a, char *b);
int (*psplsum) (int a, int b);
psplsum = sum;               // generates a compiler warning
psplsum = (int (*)(int a, int b)) sum;   // no compiler warning, cast to function pointer
psplsum = (int *(int a, int b)) sum;     // compiler error of bad cast generated, parenthesis are required.

Сравните указатель функции с равенством

Вы можете проверить, что указатель функции равен определенному адресу функции, используя if заявление, хотя я не уверен, насколько это было бы полезно. Другие операторы сравнения могут показаться еще менее полезными.

static int func1(int a, int b) {
    return a + b;
}

static int func2(int a, int b, char *c) {
    return c[0] + a + b;
}

static int func3(int a, int b, char *x) {
    return a + b;
}

static char *func4(int a, int b, char *c, int (*p)())
{
    if (p == func1) {
        p(a, b);
    }
    else if (p == func2) {
        p(a, b, c);      // warning C4047: '==': 'int (__cdecl *)()' differs in levels of indirection from 'char *(__cdecl *)(int,int,char *)'
    } else if (p == func3) {
        p(a, b, c);
    }
    return c;
}

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

И если вы хотите иметь массив указателей на функции, каждый из элементов которых содержит список аргументов, то вы можете определить указатель функции с неопределенным списком аргументов (не void что означает отсутствие аргументов, но просто не указано) что-то вроде следующего, хотя вы можете увидеть предупреждения от компилятора Си. Это также работает для параметра указателя на функцию:

int(*p[])() = {       // an array of function pointers
    func1, func2, func3
};
int(**pp)();          // a pointer to a function pointer


p[0](a, b);
p[1](a, b, 0);
p[2](a, b);      // oops, left off the last argument but it compiles anyway.

func4(a, b, 0, func1);
func4(a, b, 0, func2);  // warning C4047: 'function': 'int (__cdecl *)()' differs in levels of indirection from 'char *(__cdecl *)(int,int,char *)'
func4(a, b, 0, func3);

    // iterate over the array elements using an array index
for (i = 0; i < sizeof(p) / sizeof(p[0]); i++) {
    func4(a, b, 0, p[i]);
}
    // iterate over the array elements using a pointer
for (pp = p; pp < p + sizeof(p)/sizeof(p[0]); pp++) {
    (*pp)(a, b, 0);          // pointer to a function pointer so must dereference it.
    func4(a, b, 0, *pp);     // pointer to a function pointer so must dereference it.
}

Стиль С namespace Использование Global struct с указателями функций

Вы можете использовать static ключевое слово, чтобы указать функцию, имя которой является областью действия файла, а затем назначить ее глобальной переменной, чтобы обеспечить что-то похожее на namespace функциональность C++.

В заголовочном файле определите структуру, которая будет нашим пространством имен, вместе с глобальной переменной, которая ее использует.

typedef struct {
   int (*func1) (int a, int b);             // pointer to function that returns an int
   char *(*func2) (int a, int b, char *c);  // pointer to function that returns a pointer
} FuncThings;

extern const FuncThings FuncThingsGlobal;

Затем в исходном файле C:

#include "header.h"

// the function names used with these static functions do not need to be the
// same as the struct member names. It's just helpful if they are when trying
// to search for them.
// the static keyword ensures these names are file scope only and not visible
// outside of the file.
static int func1 (int a, int b)
{
    return a + b;
}

static char *func2 (int a, int b, char *c)
{
    c[0] = a % 100; c[1] = b % 50;
    return c;
}

const FuncThings FuncThingsGlobal = {func1, func2};

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

int abcd = FuncThingsGlobal.func1 (a, b);

Области применения указателей функций

Компонент библиотеки DLL может сделать что-то похожее на стиль C namespace подход, при котором конкретный интерфейс библиотеки запрашивается из фабричного метода в интерфейсе библиотеки, который поддерживает создание struct содержащий указатели на функции. Этот интерфейс библиотеки загружает запрошенную версию DLL, создает структуру с необходимыми указателями на функции, а затем возвращает структуру запрашивающей вызывающей стороне для использования.

typedef struct {
    HMODULE  hModule;
    int (*Func1)();
    int (*Func2)();
    int(*Func3)(int a, int b);
} LibraryFuncStruct;

int  LoadLibraryFunc LPCTSTR  dllFileName, LibraryFuncStruct *pStruct)
{
    int  retStatus = 0;   // default is an error detected

    pStruct->hModule = LoadLibrary (dllFileName);
    if (pStruct->hModule) {
        pStruct->Func1 = (int (*)()) GetProcAddress (pStruct->hModule, "Func1");
        pStruct->Func2 = (int (*)()) GetProcAddress (pStruct->hModule, "Func2");
        pStruct->Func3 = (int (*)(int a, int b)) GetProcAddress(pStruct->hModule, "Func3");
        retStatus = 1;
    }

    return retStatus;
}

void FreeLibraryFunc (LibraryFuncStruct *pStruct)
{
    if (pStruct->hModule) FreeLibrary (pStruct->hModule);
    pStruct->hModule = 0;
}

и это может быть использовано как в:

LibraryFuncStruct myLib = {0};
LoadLibraryFunc (L"library.dll", &myLib);
//  ....
myLib.Func1();
//  ....
FreeLibraryFunc (&myLib);

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

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

Вы можете использовать указатели функций как способ делегировать некоторые задачи или функции. Классическим примером в C является указатель функции делегата сравнения, используемый с функциями библиотеки Standard C qsort() а также bsearch() обеспечить порядок сопоставления для сортировки списка элементов или выполнения двоичного поиска по отсортированному списку элементов. Делегат функции сравнения определяет алгоритм сортировки, используемый при сортировке или двоичном поиске.

Другое использование аналогично применению алгоритма к контейнеру стандартной библиотеки шаблонов C++.

void * ApplyAlgorithm (void *pArray, size_t sizeItem, size_t nItems, int (*p)(void *)) {
    unsigned char *pList = pArray;
    unsigned char *pListEnd = pList + nItems * sizeItem;
    for ( ; pList < pListEnd; pList += sizeItem) {
        p (pList);
    }

    return pArray;
}

int pIncrement(int *pI) {
    (*pI)++;

    return 1;
}

void * ApplyFold(void *pArray, size_t sizeItem, size_t nItems, void * pResult, int(*p)(void *, void *)) {
    unsigned char *pList = pArray;
    unsigned char *pListEnd = pList + nItems * sizeItem;
    for (; pList < pListEnd; pList += sizeItem) {
        p(pList, pResult);
    }

    return pArray;
}

int pSummation(int *pI, int *pSum) {
    (*pSum) += *pI;

    return 1;
}

// source code and then lets use our function.
int intList[30] = { 0 }, iSum = 0;

ApplyAlgorithm(intList, sizeof(int), sizeof(intList) / sizeof(intList[0]), pIncrement);
ApplyFold(intList, sizeof(int), sizeof(intList) / sizeof(intList[0]), &iSum, pSummation);

Другой пример - с исходным кодом GUI, в котором обработчик для определенного события регистрируется путем предоставления указателя функции, который фактически вызывается, когда происходит событие. Среда Microsoft MFC с ее картами сообщений использует нечто подобное для обработки сообщений Windows, доставляемых в окно или поток.

Асинхронные функции, требующие обратного вызова, похожи на обработчик событий. Пользователь асинхронной функции вызывает асинхронную функцию для запуска некоторого действия и предоставляет указатель на функцию, которую асинхронная функция будет вызывать после завершения действия. В этом случае событие - это асинхронная функция, выполняющая свою задачу.

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

С довольно переменчивый и прощающий одновременно:)

Указатели на функции полезны, потому что, как сказано в книге "Язык программирования C", функции в C не являются переменными. Это означает,

      // Say you have add function
int add(int x, int y){
    return x + y;
}

// Say you have another add function
int another_add(int x, int y){
    return y + x;
}


int main(){
    // Although the types of another_add and add are same
    // You can't do
    another_add = add
    
    // You have a compute function that takes a function of int's signature
    int (*compute)(int, int);
   
    // You won't even be able to pass functions to other functions
    // (Although when you do, C is just passing the pointer to that function)
    // So, compute(add) is really compute(&add)
    // But you can create a pointer to functions that are variables
    // you can assign to and/or pass to other functions

    int (*operation)(int, int);
    // Now you can do
    operation = &add;
    // You could also do, the following to do the same thing
    // When a function is passed in right hand side of assignment,
    // C knows that you mean pointer, and you don't need explicit &
    operation = add;
}

Точно так же массив также не является переменной в C. Вы можете создать пример, аналогичный приведенному выше, и протестировать его.

Указатели на функции полезны во многих ситуациях, например:

  • Члены COM-объектов являются указателями на функцию ag:This->lpVtbl->AddRef(This); AddRef - указатель на функцию.
  • функция обратного вызова, например, определяемая пользователем функция, которая сравнивает две переменные, которые должны быть переданы в качестве функции обратного вызова специальной функции сортировки.
  • очень полезно для реализации плагина и приложения SDK.
Другие вопросы по тегам