it-swarm.com.ru

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

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

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

1123
Yuval Adam

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

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

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

Прежде всего, давайте определим указатель на функцию, которая получает 2 ints и возвращает 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;
}
1358
Yuval Adam

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

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

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

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

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

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

Класс 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, так что, вероятно, есть моменты, которые я не очень хорошо объяснил, или они могут быть просто неуместны с точки зрения того, как лучше всего реализовать OOP в C. Но моя цель состояла в том, чтобы попытаться проиллюстрировать одно из многих применений указателей функций.

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

283
coobird

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

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

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

212
Lee

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

#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);
}
103
Nick Van Brunt

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

  • id: ID: идентификатор - это
  • Указатель: *D: D указатель на
  • Функция: D(<parameters>): функция D принимает <parameters> возвращая

В то время как 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> returning, то есть D3(<parameters>), которой мы сейчас являемся.

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

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

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

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

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

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

Низходящий

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

ID0(<parameters>)

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

*ID0(<parameters>)

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

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

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

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

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

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

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

23
Johannes Schaub - litb

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

Их очень удобно использовать, когда вам нужны разные функции в разное время или на разных этапах разработки. Например, я разрабатываю приложение на хост-компьютере с консолью, но окончательный выпуск программного обеспечения будет помещен на 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, а код сделает все остальное!

22
Zack Sheffield

Указатель на функцию обычно определяется 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;
}
13
Eric Wang

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

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

#include <stdio.h>

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

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

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

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

    return 0;
}

Результат:

значение: 410
значение: 390

12
Vamsi

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

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

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

Объявление для переменной указателя функции должно указывать ту же информацию, что и объявление функции, чтобы компилятор 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 стиль Cast

Вы можете использовать приведения в стиле 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, что означает отсутствие аргументов, а просто неуказанный), что-то вроде следующего, хотя вы можете увидеть предупреждения от компилятора C. Это также работает для параметра указателя на функцию:

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 в стиле C с использованием глобального 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 может делать что-то похожее на подход namespace в стиле C, в котором конкретный интерфейс библиотеки запрашивается из фабричного метода в интерфейсе библиотеки, который поддерживает создание 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, доставляемых в окно или поток.

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

4
Richard Chambers

Функция запуска с нуля имеет некоторый адрес памяти, с которого они начинают выполняться. На ассемблере они называются как (вызовите "адрес памяти функции"). Теперь возвращаемся к 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");
}

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

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

3
Mohit Dabas

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

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

0
Tim Post